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){
  }
}
}

posted on 2016-02-28 19:06 gcczhongduan 阅读(150) 评论(0) 编辑收藏举报