j2se回想

执行Java程序．

Java程序有两种方式一种是jar包。一种是class. 执行jar,Java -jar XXX.jar执行的时候，Java.exe调用GetMainClassName函数，该函数先获得JNIEnv实例然后调用Java类Java.util.jar.JarFileJNIEnv中方法getManifest()并从返回的Manifest对象中取getAttributes("Main-Class")的值即jar包中文件：META-INF/MANIFEST.MF指定的Main-Class的主类名作为执行的主类。之后main函数会调用Java.c中LoadClass方法装载该主类（使用JNIEnv实例的FindClass）。main函数直接调用Java.c中LoadClass方法装载该类。假设是执行class方法。main函数直接调用Java.c中LoadClass方法装载该类。

然后main函数调用JNIEnv实例的GetStaticMethodID方法查找装载的class主类中

“public static void main(String[] args)”方法，并推断该方法是否为public方法，然后调用JNIEnv实例的

CallStaticVoidMethod方法调用该Java类的main方法。

----------------------------------------------------

堆和栈是分别管理对象和地址值的。非静态在获取实例的时候须要一个引用，（所以须要new一个对象）而静态则不须要

native 是java用来和c/c++ 打交到的，早期java刚刚出生是c/c++横行的时候，java为了适应当时的格局。所以在jvm中开辟了一块空间特地来处理c/c++的程序。

这块区域他叫做native。

而native是用来处理程序和硬件打交到的区域。

栈里面是存放地址引用，堆里面的存放的是实体对象。栈的速度快。堆比較慢。

----------------------------------------------------

JAVA_HOME

D:\Java\bin

PATH

%JAVA_HOME%;%System%.....

----------------------------------------------------

设置暂时的环境变量

set path="u盘上的jre文件bin文件的路径"，这样path的路径就变为了暂时的了。他的生命周期就在当前窗体。关闭就没有了。

javac xxx.java

class 文件不在当前目录下

-->set classpath f:\xxx\xx\ 这样子过去，能够为当前类文件设置一个暂时的路径。

----------------------------------------------------

& 过程中仅仅要有一边为假，就为假

| 过程中仅仅要有一边为真，就为真

&&左边为false时不參与运算

||左边为true时不參与运算

位运算。计算机专用，用于操作2进制的运算。

----------------------------------------------------

if(){}else if(){}else if(){} else //这个尽管由多个代码块组成。可是仅仅有一个会运行。

if 和 switch 建议仅仅使用 switch switch会把选择答案载入进内存，选择效率会高点。 int byte short char enum string

while(){}

do while(){}不管条件是否满足，循环体都要运行一次。

（\r \n回车）（\t制表符）（\转义字符）

标识符：

wai:for(int i;i<10;i++){

nei:for(int j;j<10;j++){

break wai; //跳出外循环

}

}

----------------------------------------------------

重载：方法名同样。參数个数不同，返回值类型不同。

数组：同一类型，固定个数的容器。

选择排序：1 第一个和后面的每个比較，小的放前面。内圈和外圈做比較。2 内圈的起始变量是外圈的第二个。3 来个暂时变量，为2个角标的引用做交换。

冒泡排序：1 相邻的2个数做比較。大的放后面。

2 内圈变量是外圈长度减一。3 来个暂时变量。为2个角标的引用做交换。

Arrays.sort(arr);//开发专用 ,宁外希尔排序，效率非常高。

二分法查找：1 必须是有序的。

>>>右移动4位，<<<左移动4位，在10进制中一个数&15 相当于找到自身。

Integer.toBinatyString(-6); 十--->二进制

Integer.toOctalString(-6); 十--->八进制

Integer.toHexString(-6); 十--->十六进制

----------------------------------------------------

二维数组

引用数据类型，在堆里面，默认初始化值是null。在没有不论什么指向之前他就是null。

int arr[][]={{1,2,3},{4,5,6},{7,8,9}};

int sum=0;

for(int i;i<arr.length;i++){

for(int j;j<arr[i].length;j++){

sum+=arr[i][j];

}

}

----------------------------------------------------

面向对象：

1 面向对象思想是一种符合现实社会中人们对问题思考习惯的思想。

2 把现实社会中复杂的事情简单化（eg:买电脑）

3 把运行者，变为指挥者（eg:买电脑）

--------------------

3 种引用类型的变量。

1 数组。

2 类。

3 接口。

--------------------

局部变量和成员变量的差别

1 在类中定义的位置不同

2 在内存中的生命周期不同（堆和栈）

3 生命周期不同

4 初始化值不一样。

--------------------

匿名对象的使用场景：当对象方法或属性仅仅有一次调用的时候就用匿名对象。

--------------------

五片内存区域：

1 寄存器。

2 本地方法区[和jni一起用]。

3 栈内存。

4 堆内存。

5 方法区[数据共享区]。

---------------------------------------------------------

面向对象：

1 封装：隐藏对象的属性和实现细节，仅对提供公共的訪问和操作方式。

构造函数：将对象初始化。每个类都有一个默认的构造函数。

this：表示当前对象，字节码。

谁调用这个类。this就代表谁。

{} 构造代码块。每次创建一个对象都会运行一次。而构造函数仅仅运行一次。

--------------------

static: 和方法一样。存在方法区中，而方法是在被调用的时候才进栈，被static修饰的就是一直存在方法区中。

---1 被static修饰的，优先于对象存在。

  ---2 随着类的载入而载入，消失而消失。

  ---3 被全部成员共享。

  ---4 静态仅仅能调用静态。非静态能够调用静态。

--------------------

  static（类变量(在方法区中)）object（实例变量(在堆中)）

  方法默认存储在方法区中，而当执行的时候才在栈中。

  ---------------

  static 代码块（那他和jni有什么差别呢）

  1 随着类的载入而载入，并且仅仅运行一次。

  2 优先于主函数运行。

3 给类初始化。

  ---------------

  单例模式：为了保证一个project仅仅有一个对象。

  eg: 对象也能够用来封装数据。

1 懒汉式。

2 饿汉式。

由于static 是随着类的载入而载入的，浪费内存。

所以为了避免一定的空间浪费，开发中推荐懒汉式，特别是android

单例中出现的方法。是为了[可控]

--------------------------------------------------------

2 继承：（单继承[调用的不确定性],多实现）

1 让类与类之间产生了关系。

2 对共性进行了抽取(属性和方法)。

3 子类能够调用父类的属性和方法。前提是仅仅能訪问父类中public的。

并且子类中使用的时候不会自己主动提示，可是我们手动写。

4 在子类的全部构造函数的第一行，默认有一句 super(),他会去调用父类的构造方法。

5 【凡是】子类继承父类。父类和子类的属性，都在子类的堆内存区其中。所以父类有的，子类就能够不用写了。写了就是内存浪费。

特殊情况[android 自己定义控件]例如以下：

6 当子类重写父类了的方法之后。就会将父类的方法进行屏蔽。以后调用这种方法，都是去运行子类的逻辑，在android自己定义控件中用的比較多。

7 结论：父类的构造函数，既能够给本类对象初始化，也能够给子类对象初始化。

------------------

继承就是不断的向上抽取。仅仅有在其子类才有特有的功能，什么时候继承得看情况。

this能够代表当前对象。super 代表父类空间。

被private 修饰的不能被子类继承訪问。

可是子类的堆内存中有。

当子父类中出现一摸一样的方法时。子类会覆盖（重写）父类的方法。

而且子类的权限要>=父类。

重载是函数名同样，參数不同。和覆盖不一样。

static仅仅能覆盖static

在一个类中：当有參构造的出现，默认的无參构造会消失。

继承会把父类中的所有public的功能所有拿过来。

------------------

final

被final 修饰的属性不能改动、类不能继承、方法不能重写。

在开发中常量就能够用final 来修饰，可是名称得大写。

并且在继承中，假设子类中有，默认是调用子类的，子类没有才调用父类的。

构造代码块：在super()和自己的代码之间，会调用构造代码块。

------------------

一个对象在内存中产生的过程：

1 将该对象所需的类文件载入进内存。

2 在内存中进行空间的方法区的空间分配。

3 通过new 在堆中开辟空间。

4 对象中的属性进行默认初始化。

5 调用与之对象的构造函数进行初始化。

6 通过构造函数的super调用父类中的构造函数初始化。

7 对象中的属性进行显示初始化。

8 构造代码块初始化。

9 该构造函数内部自己定义内容进行初始化。

------------------

抽象：is a [是]（多个子类继承同一个父类）

当你描写叙述一个事物的时候，没有足够的信息对该事物进行描写叙述，那么这个事物相应的类就是一个抽象类。

抽象类不能实例化。

抽象类中的方法必须所有重写。

抽象类中能有自己的特有方法。（接口不能）

抽象类必需要被继承。

子类能继承一切非 private 的方法。

继承的本意在于抽象，而非代码的重用。

-----------------

接口：like a [像]（多个接口能被同一个类实现）

接口里面的方法都是抽象方法。

接口里面的常量都是静态不可被改动的。

接口仅仅能实现不能被new。

接口能多实现。

（攻克了java的单实现的问题）

接口能继承接口。并且接口能够【多继承】。

接口的出现是为了定义额外的功能。

------------------

接口回调：

1 在Fragment类中定义一个Test接口。

2 在Fragment类中定义一个接口对象常量。

3 在Fragment类中定义一个方法。为接口的引用赋值，參数是实现类的子类。

4 在MainActivity类中实现Test接口。重写接口里面的方法。在方法里面写上自己的逻辑。

5 在TestCallBack类中new Fragment这个对象。

调用实例化接口的那个方法。參数是new　MainActivity();（假设执行null，就传this吧）

-----------------

3 多态：

父类或接口的引用指向子类的实例对象。

优点:提高了代码的拓展性。

坏处:不能使用子类的特有内容。

假设想使用子类的特有功能，就得向下转型。

instanceof:向下转型的keyword，仅仅能用于引用类型的推断。

多态-成员变量：编译执行都看左边。

多态-成员函数：编译看左边，执行看右边。

-----------------------------------------------

多线程：

进程：正在运行的任务程序。

线程：程序运行的程序。

自己定义线程执行的任务都执行在run方法中。

当调用。start()方法后，线程内部。会自己主动运行run() 方法;

有2种方式创建线程。

1 实现Runnable接口。（这个比較好可以起拓展用的）

2 继承 Thread 类。

（这个比較硬编码）

同步锁：

仅仅要保证锁是同一个锁就不会出现线程安全的问题。

JDK 1.5 之后。Lock替代了同步，Condition替代了Object中的监视器方法。

private final Lock lock=new ReentrantLock();//创建锁对象

private Condition xiaofei=lock.newCondition();//子锁1

private Condition shencan=lock.newCondition();//子锁2

lock.lock();//加锁

xiaofei.await(); //等待

shencan.signal(); //唤醒

lock.unlock();//解锁

----------------------------------------------

eclipse 模板

方法中去掉无用的凝视 java->code style ->code templates

自己定义快捷键 java->Editor-> Templates

----------------------------------------------

StringBuffer(线程安全，在多线程的时候使用) StringBuilder(线程不安全，没有线程的时候。开发中建议使用这个)

字符串比較。实现 Comparable 接口，调用 Comparto()方法,会依照字典大小排序。他的返回值是0或1。

----------------------------------------------

基本数据类型，字符串转为对象 Character

toLowerCase(char ch);【指定字符串：变小写】

toUpperCase(cher ch);【指定字符串：变大写】

------------

toBinatyString 二进制

toHexString 十六进制

toOctalString 八进制

==================================================集合记住 Collection 下的集合都能被迭代 Iterator

集合长度可变。数组长度不可变。

集合能够存储多种类型对象，数组仅仅能存储单一类型的对象。

Iterator是Collection全部子集合共性抽取的迭代接口;

Collection[接口] (集合都有：增，删。改，查。的方法)

List: 链表结构：能够模仿堆栈。

注意问题：在迭代集合的时候，/*假设须要对集合进行并发操作，会出现并发改动异常*/，我们得把Iterator 换为ListIterator。

   他的功能比 Iterator很多其它。（详情查看api）

    非线程安全：

    ArrayList 查询快。增删慢。

    LinkedList 增删快。查询慢。【能够用来模仿堆栈 addLast(),removeFlast()】



    /*线程安全*/。在多线程的时候使用：

    Vector 底层是数组结构。他迭代的时候能够用枚举接口， Enumeration 来迭代。由于枚举在的时候还没有集合框架。

  Set: 集合结构：能够用来去重。

HashSet 无序的。

存储时速度巨快，由于底层是依据哈希算法来实现的。

可是不关心顺序，而且唯一。

须要查询hashCode() 和equers()

自己定义对象(往哈希表中存储数据的时候)要重写 equals()，HashCode() 方法。

才干做比較。

    自己定义对象(假设想让对象具备比較大小的功能，依照自然顺序排序，必需要实现 Comparable接口 )

    eg：/*牛逼的equers()方法

     public boolean equers(Object obj){

      if(this==obj){//比較地址

       return true;

      }

      if(!(obj instanceof Student)){

       throws new ClassCastException("类型不匹配，无法比較");

      }

      Student stu=(Student) obj;

      return this.name.equals(stu.name) && this.age==stu.age;

     }

     */

   TreeSet:

    排序方式1：

     使用元素的自然顺序进行排序。他保证数据的唯一性,是在自己定义对象中实现 Comparable接口重写compareTo()看返回值是否为0，为0就是反复的元素。

排序方式2：

定义一个比較器，让对象一初始化就具备比較功能。实现 Comparator 接口。

重写 compare()方法,相等返回0;

     假设须要先依照字典排序又要依照长度排序，那么就得在compare()里面继续调用 compareTo() 方法了。

     实现原理是二叉树比較法。就像二分查找法一样。

     person p=(person)o;

     int temp =this.age-p.age;

     return temp==0?this.name.compareTo(p.name):temp;

   LinkedHashSet:

    有序且去反复的列表：



  范型:

   上边界: ?

extends person (传递进来的參数仅仅能为 person的本身或者子类型)

   下边界: person super ? ()

  泛型类：

  省去了以前的强转和类型转换异常的麻烦。（将泛型定义在类上。使用者仅仅须要在使用这个类的时候传入泛型就能够了）

  详细什么类型由使用者确定。

eg： public Util<T>{   //使用方仅仅须要   这样使用    Util<Person> u=new Util<Person>

    private T t;//        u.setT(new Person());

    public void setT(T t){//     u.getT();

     this.t=t;

    }

    public T getT(){

     return t;

    }

   }



  泛型方法：在不确定方法的參数的时候，须要什么类型自己传递 (基本数据类型。或者对象类型，都能够)

  eg: public <W> void show(W w){

    System.out.println("w:"+w);

   }



  泛型接口：也是传入的參数不确定的时候使用的。

  eg：public interfrace inner<V>{

    public abstract void show(V v);

   }

   class innerImpl<C> implements inner<C>{

    public void show(C c){

     System.out.println("c:"+c);

    }

   }



   main(String[] args){

    new innerImpl<Integer>().show(new Integer(3));

    new innerImpl<String>().show(new String("ok"));

   }

  fore() 循环。不操作角标，能操作数组和 Connection集合;



Map(Key,Value):

  key不能反复;

  取值有2种方式：

   1 map.keySet 得到全部key的集合

   2 map.entrySet 得到全部key和value的集合 (entry 实体对象)





  1.0 Hashtable 线程安全,key value不同意为空（和Vector一个时代的）

  1.2 HashMap   线程不安全,key value同意为空【假设是自己定义对象，在迭代的时候要去除反复的key,能够參阅 250行牛逼的equers()方法】

   TreeMap   底层是二叉树实现的，假设想让自己定义对象也具有比較性，必须实现 Comparable接口,查询 compareTo();

   LinkedHashMap 有序结构的链表集合（内部模拟了堆栈的实现）

   //Properties 他也是键值对的属性集。重要的是他能持久化这个集合，用于IO流读取。他的父类是HashTable



专门操作集合的工具类:

Collections   eg:详情查看api; 工具类中有，synchronizedCollection(),List,Map能够将非同步的集合转为同步的集合。

Arrays    eg:详情查看api; asList(int[] i)数组转集合。

可是有些方法是不能用的。

由于集合是固定的。不能做增删操作。

toArray()集合转数组。

定义类型必须一致。

可变參数： ... 能够替代非常多个数的数组，前提是必须放在參数列表的最后面。

其它api：

System：有一个非常有意思的api。 System.getProperties()他能返回这个整个环境和工具的信息的集合。

还能够通过集合里面特定的key值，能够在不同平台下都能使用的特殊功能符号。

Runtime：这是一个底层由单例模式完毕的执行时类。通过Runtime.getRuntime()能够得到他的对象。详情查看 api

eg：启动qq Runtime.getRuntime().extc("qq.exe");{这里面，写的的是Dos命令}

Math: abs()绝对值 , ceil 天花板 floor地板 round四舍五入 Max最大 Min最小 pow幂运算，... 正旋余弦很多其它查看api

IO流：用来处理设备间的传输数据。分输出流和输入流。

{仅仅要对象一创建就有文件。

假设已经存在会被覆盖}

使用完之后一定要记得关闭流对象。并且得放在finally中，并且这个流对象还得做非空推断，防止对象没有创建成功，报null异常。

因为操作系统不同。有的时候\r\n 不好使，所以我们使用 System.getProperty("line.separator");

字节流：

InputStream OutputStream: （看顶层，用底层）

FileInputStream

FileOutputStream

字节流能够直接将内容写到目的地，不须要暂时存储就能操作文件，比字符流少了走缓冲区这一步。

他是直接操作字节的。

装饰模式：

BufferedInputStream 对已有的对象提供了额外的功能，还不用对源对象进行改动，避免了继承的臃肿。

BufferedOutputStream

转换流：（事实上我想说：他也是代理模式么？）

InputStreamReader(new InputStream()):字节转字符，将内存看不懂的字节转为能够看懂的文字。

OutputStreamWriter(new OutputStream()):字符转字节。将看的懂的文字转为内存为看不懂的字节。

字符流：（字节流+编码表）

Reader Writer:

FileWriter FileReader

文件操作流。

对文件进行续写 new FileWriter("demo.txt",true);

在内存中定义高效的缓冲区:(一般获取内存中的速度远比直接获取目的地的数据快高效)

BufferedReader(new FileReader()); BufferedWriter(new FileWriter());

装饰模式：

[事实上BufferedReader 这样的方式是典型的装饰模式的应用：对已有的对象提供了额外的功能，还不用对源对象进行改动，避免是继承的臃肿]

BufferedReader(new FileReader());

LineNumberReader(new FileReader());

IO流4步曲

1 明白源和目的 I O

2 是否纯文本 FileReader

3 明白设备

4 是否须要高效 BufferReader

转行流：

InputStreamReader(),指定编码表 InputStreamReader(is,"UTF-8");

OutputStreamWriter(),指定编码表 OutputStreamWriter(os,"UTF-8");

File 类:

File.separator 名称分隔符,在不论什么环境下都能使用。linux和windows下都能识别。他会自己主动转换

File.getTotalSpace() 总大小

File.getFreeSpace() 剩余空间

File.deleteOnExit();退出系统的时候会自己主动删除文件(所以在我们创建文件之后能够立刻写这句话)

File.isFile() 是否为文件

File.isDirectory() 是否为目录

file.list(new filter());文件过滤器

file.listFilse(new filter());目录过滤器

SequenceInputStream 合并流：

public static void main(String[] args) throws IOException {

  将多个流进行逻辑串联(进行合并,变成一个流，操作起来非常方便，由于多个源变成了一个源)

  FileInputStream fis1 = new FileInputStream("tempfile\\seq_1.txt");

  FileInputStream fis2 = new FileInputStream("tempfile\\seq_2.txt");

  FileInputStream fis3 = new FileInputStream("tempfile\\seq_3.txt");



  ArrayList<FileInputStream> v = new ArrayList<FileInputStream>();

  v.add(fis1);

  v.add(fis2);

  v.add(fis3);

  Enumeration<FileInputStream> en = Collections.enumeration(v);

  SequenceInputStream sis = new SequenceInputStream(en);

  //创建目的。

  FileOutputStream fos = new FileOutputStream("tempfile\\seq_4.txt");

  byte[] buf = new byte[1024];

  int len = 0;

  while((len=sis.read(buf))!=-1){

   fos.write(buf,0,len);

  }

  fos.close();

  sis.close();

}

RandomAccessFile:多线程下载专用流。

seek(8); 能随机操作指针的方法，能够开启多个线程同一时候操作这个对象。达到多线程下载。

从看不懂到看得懂解码，从看的懂到看不懂，编码。

文件加密：

public static void main(String[] args) throws IOException {

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("copy4.mp3")); // 创建流对象,并给流对象加上缓冲区

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy5.mp3"));

//  byte[] buf=new byte[1024]; 操作字节的时候，自己定义的缓存数组就不要了，会导致垃圾产生

  int b=0;

  while ((b = bis.read(/*buf*/)) != -1) {

   bos.write(b ^ 111);//这个11 就是密钥

  }

  bis.close();

  bos.close();

}

网络编程：

UDP：

不须要建立连接速度快。数据限制大小在64k之内，无连接，不可靠协议。

TCP：

须要建立连接。经过3次握手。能够进行大传输数据，是可靠协议，但效率会稍低。

TCP协议，多线程上传文件，源代码

public class UploadPicClient {

public static void main(String[] args) throws UnknownHostException, IOException {

  if(args.length!=1){

   System.out.println("请指定文件");

   return;

  }

  File file = new File(args[0]);

  if(!(file.exists() && file.isFile())){

   System.out.println("该文件不存在，或不是正确的文件,又一次指定");

   return;

  }

  if(!(file.getName().endsWith(".jpg") || file.getName().endsWith(".gif"))){

   System.out.println("文件扩展名必须是jpg。或者而是 gif。");

   return;

  }

  if(file.length()>=1024*1024*2){

   System.out.println("文件过大，又一次选择，");

   return;

  }

  Socket s = new Socket("192.168.1.100",10006);

  FileInputStream fis = new FileInputStream(file);

  OutputStream out = s.getOutputStream();

  byte[] buf = new byte[1024];

  int len = 0;

  while((len=fis.read(buf))!=-1){

   out.write(buf,0,len);

  }

  //告诉server端，发送数据完成，发送一个结束标记。

  s.shutdownOutput();

  InputStream in = s.getInputStream();

  byte[] bufIn = new byte[1024];

  int lenIn = in.read(bufIn);

  String info = new String(bufIn,0,lenIn);

  System.out.println(info);

  fis.close();

  s.close();

}

}

public class UploadPicServer {

public static void main(String[] args) throws IOException {

//服务端，接收client发送过来的图片数据。进行存储后，回馈一个上传成功字样。多用户的并发訪问。

ServerSocket ss = new ServerSocket(10006);

  while(true){

   Socket s = ss.accept();



   new Thread(new UploadThread(s)).start();

  }

//  ss.close();

}

}

public class UploadThread implements Runnable {

private Socket s;

public UploadThread(Socket s) {

  super();

  this.s = s;

}

@Override

public void run() {

  String ip = s.getInetAddress().getHostAddress();

  System.out.println(ip+"......connected");

  try{

  //读取数据。网络。

  InputStream in = s.getInputStream();

  File dir = new File("c:\\mypic");

  if(!dir.exists())

   dir.mkdir();

  int count = 1;

  File file = new File(dir,ip+".jpg");

  while(file.exists()){

   file = new File(dir,ip+"("+(count++)+").jpg");

  }

  //目的:文件

  FileOutputStream fos = new FileOutputStream(file);

  byte[] buf = new byte[1024];

  int len = 0;

  while((len=in.read(buf))!=-1){

   fos.write(buf,0,len);

  }

  OutputStream out = s.getOutputStream();

  out.write("上传成功".getBytes());

  fos.close();

  s.close();

  }

  catch(IOException e){

  }

}

}

巴特西

j2se回想

最新文章

热门文章