执行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:Javain
PATH
%JAVA_HOME%;%System%.....
----------------------------------------------------
设置暂时的环境变量
set path="u盘上的jre文件bin文件的路径"，这样path的路径就变为了暂时的了。他的生命周期就在当前窗体。关闭就没有了。
javac xxx.java
class 文件不在当前目录下
-->set classpath f:xxxxx 这样子过去，能够为当前类文件设置一个暂时的路径。
----------------------------------------------------
& 过程中仅仅要有一边为假，就为假
| 过程中仅仅要有一边为真，就为真
&&左边为false时不參与运算
||左边为true时不參与运算
位运算。计算机专用，用于操作2进制的运算。
----------------------------------------------------
if(){}else if(){}else if(){} else //这个尽管由多个代码块组成。可是仅仅有一个会运行。
if 和 switch 建议仅仅使用 switch switch会把选择答案载入进内存，选择效率会高点。 int byte short char enum string
while(){}
do while(){}不管条件是否满足，循环体都要运行一次。
（
回车） （ 制表符） （转义字符）
标识符：
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异常。
因为操作系统不同。有的时候
不好使，所以我们使用 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){
}
}
}