一、概述
java的三中技术架构 ：
EE：开发企业环境下应用程序，主要针对web
SE：完成桌面应用程序的开发，是EE、ME的基础
ME：开发电子消费产品和嵌入式设备，如手机程序
-------------------------------------------------------------------------------------
jdk：java的开发和运行环境（其自身带有jre）
jre：java的运行环境，包括java api 和 JVM
-------------------------------------------------------------------------------------
配置环境
让JDK bin目录下的工具可以在任意文件夹下运行
（将jdk的地址告诉系统，用时让系统帮我们去找）
具体 过程
打开 控制面板->系统和安全->系统->更改设置->高级->环境变量
方法一：
在系统变量中找到Path（没有就新建一个一般是有的）
直接给Path配置JDK bin目录的绝对路径
例如：Path=C:\Program Files\Java\jdk1.8.0_111\bin（根据你自己jdk安装的位置而变）
例如：Path=****;C:\Program Files\Java\jdk1.8.0_111\bin;****（***表示有其他内容）
例如：Path=****;C:\Program Files\Java\jdk1.8.0_111\bin
方法二：
在系统变量中新建JAVA_HOME
给它配置上你电脑上jdk的绝对路径
JAVA_HOME=C:\Program Files\Java\jdk1.8.0_111（根据你自己jdk安装的位置而变）
在系统变量中找到Path（没有就新建一个一般是有的）
例如：Path=%JAVA_HOME%\bin
例如：Path=****;%JAVA_HOME%\bin;****（***表示有其他内容）
例如：Path=****;%JAVA_HOME%\bin
基本上如上配置就行还有个classpath说下
这个配置不配置都行，那么它是干什么的呢？
故名思意：字节码文件路径，也就是java命令时要去哪里找编译好的.class文件路径
那为啥配不配都行呢，那是因为（jdk5）后jdk默认.class路径为当前路径（javac编译路径）即
.java和.class是在同一文件夹下所有系统能找到他；
如果配置了那系统首先会去classpath目录下搜索，找到就运行它
那如果找不到还会在当前文件夹下搜索吗？
1：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录
再找一次。
2：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再
当前目录找。
参考至：http://blog.csdn.net/u013189927/article/details/51195303
-------------------------------------------------------------------------------------
java命令和javac命令
javac命令负责编译 将指定的.java文件编译成jvm可以识别的.class文件
java命令负责启动jvm，加载运行时所需类库，运行.class文件
（main函数是被执行的起始点）
-------------------------------------------------------------------------------------
二：java语法基础（java区分大小写）
主函数：保证所有类的独立运行，是程序的入口，被jvm调用
关键字：java语言中已经赋予特殊含义的单词，不能被作为变量名和过程名（包名，
类名、接口名等等）
例如：int,char,class等等
保留字：未来要定义成关键字的单词，同样不能作为变量名和过程名
标识符：其实就是在程序中自定义的名词。比如类名，变量名，函数名
由字母、数字、下划线、美元符构成，不能以数字开头
常量：由final和static一起声明的变量定义时产生一般建议以全大写来命名
（无论new多少个对象常量只有一个，且它在定义时就必须被赋值可以直接
赋值也可以变量赋值（变量赋值时变量如果有赋值则常量为该值，否则为改变量类型默认值）
）
static块（一次http请求中假如有多次使用用一个有静态块的类，static块只会执行一次）
变量：{
内存中的一个存储空间，用于存储数据
方便运算不确定的数据，变量空间可以重复使用
命名一般用驼峰式
作用域：变量定义的位置开始，到该变量所在的那对大括号结束
生命周期：变量从定义的位置开始就在内存中活了；
变量到达它所在的作用域的时候就在内存中消失了；
}
-------------------------------------------------------------------------------------
数据类型：
基本数据类型：byte 1字节、short 2字节、int 4字节、long 8字节、float 4字节、double 8字节、char 2字节、boolean 1字节（不同语言所占字节不同）
引用数据类型: 数组、类、接口。（函数传引用时传的是地址）
级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；
（可能会溢出或丢失必须由程序员自己转换）
-------------------------------------------------------------------------------------
算术运算符
+、-、*、/、%：任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算
++、--
-------------------------------------------------------------------------------------
连接符
+：连接字符串
-------------------------------------------------------------------------------------
赋值运算符
=、+=、-=、*=、/=、%=
例如a+=b,a/=b等同于 a=a+b;a=a/b;
-------------------------------------------------------------------------------------
比较运算符
==、！=
-------------------------------------------------------------------------------------
逻辑运算符
& | ^ ! && ||
除了！外其他都是用于连接两个boolean表达式
&：只有两边结果都为true结果才为true。否则就错
&&：只有两边结果都为true结果才为true。否则就错
&和&&的区别：&&会短路，&不会
短路：左边为true时会去判断右边，左边为false时直接返回false不去判断右边
|：只要两边都为false结果是false，否则就是true
||：只要两边都为false结果是false，否则就是true
|和||的区别：||会短路，|不会
短路：左边为true时直接返回true，左边为false时才去判断右边
^：异或和！=有点像
两边结果一样就为false
两边结果不一样就为true
位运算符：用于操作二进制的运算符
& | ^ << >> >>>无符号右移
练习：两个int数据进行交互，不用第3方变量
int a=3,b=5;
a=a+b;
b=a-b;
a=a-b;
a=a^b; 1111000
b=a^b; 0100110
a=a^b; 1011110
高效算出
例子 2*8=2<<3;
<<（有符号）逻辑左移 低位补0 以起点为准
>>（有符号）逻辑右移 正数高位补0 负数数高位补符号位 以起点为准
>>>（无符号）逻辑右移（注意并没有无符号逻辑左移）高位补0 以起点为准（计算机只认补码）
都是移到二进制，如上例int在java中占4个字符32个位首尾是符号（1表示负数0表示正数）
2变成2进制******0000000010（太多0就不写了）总32位
向左移到3位******0000010000转成十进制2^4也就是16
如果是负数
例如-2
1000。。。。010
1111.。。。。101
1111.。。。。110
到了这一步在去执行<< >> >>>操作
例如>>1
1111.。。。。111
1111.。。。。110
1000.。。。。001
-1
int类型的取值范围为[-2^31,(2^31)-1](负数在java中是以补码存在的)
&:位与
000010
110110
000010
|：位或
000010
110110
110110
-------------------------------------------------------------------------------------
三、语句
if...else switch do..while while for
（因为这些都是常见的在这里不做过多介绍）
switch和if。。else有点相似，两者看情况使用，（switch 只支持enum、int、string，char）
使用switch时最好将case后要执行的过程封装成方法这样是代码美观切易于理解。
do...while和while的区别在于前者要先运行一次在判断而后者要先判断在运行
break：作用于switch和循环结构，用于跳出，或者称为结束当前循环
continue：只作用于循环结构
结束本次循环，继续下一次循环
函数：为了提高代码的复用性，可以将其定义为一个独特的功能，该功能的体现就是
java的函数
格式：
修饰符 返回值类型 函数名（参数类型 参数，，，，）{
过程
return ？？；
}
当函数没有具体的返回值时，返回的返回值类型用void关键字表示。
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。
return的作用：结束函数。结束功能。
如何定义一个函数？
函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成：
明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。
在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表
(参数类型&参数个数)。
函数中只能调用函数，不能定义函数。
函数名称最好和函数功能挂钩（增加阅读性），
重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，
只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。
数组：用于存储同一种类型数据的容器；
下标从0开始
如何定义数组：
元素类型【】 变量名=new 元素类型【n】； n可以是一个变量；
元素类型【】 变量名={元素，元素，，，，，，}；
元素类型【】 变量名=new 元素类型【】{元素，元素，，，，，，}；
二分查找法。必须有前提：数组中的元素要有序。
public static int halfSeach_2(int[] arr,int key){
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)>>1; //(max+min)/2;
while(arr[mid]!=key){
if(key>arr[mid]){
min = mid + 1;
}
else if(key<arr[mid])
max = mid - 1;
if(max<min)
return -1;
mid = (max+min)>>1;
}
return mid;
}
java分了5片内存。
1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
1：每一个实体都有内存首地址值。
2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
3：垃圾回收机制
4：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
只要数据运算完成所在的区域结束，该数据就会被释放。
5：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
-------------------------------------------------------------------------------------
四、面向对象
以前是面向过程（我理解成以前是写一个个函数去完成项目）
而面向对象是对函数等一系列内容进行封装；
匿名对象当对象只调用一次时可以使用 new Trees（）.plant（）；
类中的成员有两种
1、成员变量：其实就是类的属性
2、成员方法：其实就是成员函数
定义一个类就是定义上述的2种成员，那你首先得分析要定义的类的需求
成员的4中权限
public private protect 包权限（默认）
public：所有人都能访问
private：自己本身可以访问，别人都访问不了
protect：被自己访问和自己的子类访问和同包中可以访问
包权限：同一个page中可以访问和自己可以访问
开发是属性是用于存储数据的，直接被访问容易出现安全隐患，所以
通常都是私有化在提供方法去访问它
成员变量和局部变量的区别：
成员变量定义在类中，而局部变量定义在方法，语句，参数中
成员变量在该类的对象（针对同一个对象）存在期间一直存在
而局部变量在该方法完成时就会被销毁
成员变量在堆内存中
局部变量在栈内存中
构造函数：为对象进行初始化，它有针对性（针对调用他创建的对象），是函数的一种
1、改函数名和类名一样
2、不需写返回值类型
3、更不需要return
一个类在定义时如果自己没定义构造函数那会默认给它一个空的构造函数
但是如果你定义了构造函数你默认便不会执行所以最好养成给它一个空的构造
也即是说类可以出现重载的构造函数
构造函数和其他函数的区别：
1、格式不同
2、构造函数是在对象创建时被调用，且只执行一次，以后你想用都不行
一般函数，是对象创建后才被调用，想调几次就调几次
如何写构造函数
分析有无一开始就具备的属性或者需要去执行的行为（调用方法）
如果有需求就写在其中，没有就键一个空的构造函数
构造代码块和构造函数的区别
构造代码块是给所有的对象创建时都会调用的
构造函数值针对调用的了它所创建的对象
顺便说下何为构造代码块在类中没有前后缀的大括号区域
public Text{
{
system.out.println（“x”）；
}
}
普通代码块：函数，方法后面的大括号
同步代码块：使用synchronize关键字修饰的大括号也就它后面的大括号
应用于多线程下的对象锁定
静态代码块，以static关键字修饰的大括号也就它后面的大括号
在类被使用的第一次加载，且一直存在，直到类被使用的区域生命周期结束为止
静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 à 构造代码块 à 构造函数；
创建一个对象在内存中做了什么
1将编译好的.class文件加载进来
2执行main方法时，在栈内存开辟main方法的空间，然后main方法的栈区分配一个
变量p
3在堆内存中开辟实体空间，分配一个内存首地址值
4在该实体空间中进行属性的空间分配，并进行了默认初始化
5对空间中的属性进行显示初始化
6进行实体的构造代码块初始化
7调用该实体对应的构造函数，进行初始化
8将地址赋值给p，p变量引用该实体
（2有点不懂）
封装
隐藏对象的属性和实现细节（函数），仅对外提供公共访问方法
将变化隔离，便于使用，提高重用性，安全性
this
代表对象，就是所在函数所属对象
this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；
this对象后面跟上 () 调用的是本类中的对应参数的构造函数。
用this（）调用构造函数，必须定义在构造函数的第一行。应为如果在构造
函数的第一行没有找到this（）或super时系统会自动补上super（）这样就相当于
使用了父类的无参构造函数，那么它在构造函数的下面又使用了this（**）那就去
调用本类的其他构造函数这个时候又相当于去调用父类的无参构造函数，造成资源的
浪费或是出现一些不意料之外的结果
static：静态关键字 用于修饰成员变量或者是方法
作用在成员变量时相当于类的全局变量只属于类本身，任意其他对象对
它的操作都影响到其他对象
作用在函数时可以不必new一个对象，直接类名.函数名调用
静态方法只能访问静态成员和方法，不可以访问非静态成员和方法
因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
相反则没有这个限制
静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
什么时候定义静态成员呢？
成员分两种：
1，成员变量。（数据共享时静态化）
该成员变量的数据是否是所有对象都一样：
如果是，那么该变量需要被静态修饰，因为是共享的数据。
如果不是，那么就说这是对象的特有数据，要存储到对象中。
2，成员函数。（方法中没有调用特有数据时就定义成静态）
如果判断成员函数是否需要被静态修饰呢？
只要参考，该函数内是否访问了对象中的特有数据：
如果有访问特有数据，那方法不能被静态修饰。
如果没有访问过特有数据，那么这个方法需要被静态修饰。
成员变量和静态变量的区别：
1，成员变量所属于对象，所以也称为实例变量。
静态变量所属于类，所以也称为类变量。
2，成员变量存在于堆内存中。
静态变量存在于方法区中。
3，成员变量随着对象创建而存在，随着对象被回收而消失。
静态变量随着类的加载而存在，随着类的消失而消失。
4，成员变量只能被对象所调用。
静态变量可以被对象调用，也可以被类名调用。
所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。
-------------------------------------------------------------------------------------
设计模式
单例设计模式
用处保证一个类的对象在内存中的唯一性
多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。
如何保证对象唯一性呢？
思想：
1，不让其他程序创建该类对象。
2，在本类中创建一个本类对象。
3，对外提供方法，让其他程序获取这个对象。
步骤：
1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；
2，就在类中创建一个本类的对象；
3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）
代码体现：
1，私有化构造函数；
2，创建私有并静态的本类对象；
3，定义公有并静态的方法，返回该对象。;
例子：
public class TokenUtils {
private TokenUtils() {}
private static final TokenUtils instance = new TokenUtils();
public static TokenUtils getInstance(){
return instance;
}
public String makeToken(){
String token = (System.currentTimeMillis() + new Random().nextInt(999999999)) + "";
try {
MessageDigest md = MessageDigest.getInstance("md5");
byte md5[] = md.digest(token.getBytes());
//base64编码--任意二进制编码明文字符 adfsdfsdfsf
Base64 encoder = new Base64();
return encoder.encodeAsString(md5);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}
-------------------------------------------------------------------------------------
继承：
1：提高了代码的复用性。
2：让类与类之间产生了关系，提供了另一个特征多态的前提。
父类的由来：其实是由多个类不断向上抽取共性内容而来的。
java中对于继承，java只支持单继承。java虽然不直接支持多继承，
但是保留了这种多继承机制，进行改良。
单继承：一个类只能有一个父类。
多继承：一个类可以有多个父类。
为什么不支持多继承呢？
因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。
但是java支持多重继承。A继承B B继承C C继承D。
多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。
所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。
简单说：对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。
子父类出现后，类中的成员都有了哪些特点：
1：成员变量。
当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。
如果想要调用父类中的属性值，需要使用一个关键字：super
This：代表是本类类型的对象引用。
Super：代表是子类所属的父类中的内存空间引用。
注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。
2：成员函数。
当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖(复写，重写)
什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。
3：构造函数。
发现子类构造函数运行时，先运行了父类的构造函数。为什么呢?
原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();
super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。
为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)
因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。
注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。
问题：super()和this()是否可以同时出现的构造函数中。
两个语句只能有一个定义在第一行，所以只能出现其中一个。
super()或者this():为什么一定要定义在第一行？
上面已经有详细诉过
继承的细节：
什么时候使用继承呢？
当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。
英文书中，所属关系：" is a "
在方法覆盖时，注意两点：
1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。
2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)
继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是不需要被继承，或者复写的。
这时如何解决问题呢？介绍一个关键字，final:最终。
final特点：
1：这个关键字是一个修饰符，可以修饰类，方法，变量。
2：被final修饰的类是一个最终类，不可以被继承。
3：被final修饰的方法是一个最终方法，不可以被覆盖。
4：被final修饰的变量是一个常量，只能赋值一次，一般会和static组合定义常量
常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用 _ 连接
抽象类: abstract
抽象：不具体，看不明白。抽象类表象体现。
在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。
例如：public abstract void ppx();
抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。
抽象类的特点：
1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
2：抽象方法只定义方法声明，并不定义方法实现。
3：抽象类不可以被创建对象(实例化)。
4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
抽象类的细节：
1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。
2：抽象类中是否可以定义非抽象方法？
可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
3：抽象关键字abstract和哪些不可以共存？final , private , static
（抽象关键字本来就没有具体实现需要通过继承来实现，凡是阻碍其被继承的存在都不可和其搭配）
4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
模板方法设计模式：
解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
abstract class GetTime{
public final void getTime(){ //此功能如果不需要复写，可加final限定
long start = System.currentTimeMillis();
code(); //不确定的功能部分，提取出来，通过抽象方法实现
long end = System.currentTimeMillis();
System.out.println("毫秒是："+(end-start));
}
public abstract void code(); //抽象不确定的功能，让子类复写实现
}
class SubDemo extends GetTime{
public void code(){ //子类复写功能方法
for(int y=0; y<1000; y++){
System.out.println("y");
}
}
}