执行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.javaclass 文件不在当前目录下
-->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幂运算，... 正旋余弦 很多其它查看apiIO流：用来处理设备间的传输数据。分输出流和输入流。
{仅仅要对象一创建就有文件。
假设已经存在会被覆盖}
使用完之后一定要记得关闭流对象。并且得放在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){ } } }