三天学会Java：经验是从错误中得来的!!!
第一部分：基本语法
1，Java的特点
跨平台性、面向对象、安全性
2，环境变量的搭建;
环境变量是用Java进行编程的关键，没有环境变量的搭建，就如同想玩网络游戏但没有
申请网络游戏号一样。所以很重要，但是也很简单
最简便的方法：
1，在网上下载或从别人那里考一个Jdk1.5或Jdk1.6版本的文件，存放在一个
固定盘符下，如C盘；
2，打开Jdk文件，连续打开到jdk...bin目录下；
3，在“我的电脑”图标上点击右键-->属性-->高级-->环境变量-->path(双击)；
4，复制bin目录到path目录的开始部分(这样可以保证在dos运行时为当前目录)
并以分号结尾。然后连续点击“确定”就可以了。
3，Java虚拟机与JDK
将代码都保存在一个扩展名为.java的文件中
使用JDK提供的工具javac.exe对java文件进行编译，生成扩展名为.class 字节码文件
使用JDK提供的工具java.exe对字节码文件进行运行
4，Java编程基础
<1>Java语法格式
任何一种语言都有自己的语法规则，Java也一样，既然是规则，那么知道其如何
使用就可以了。
a,代码都定义在类中，类由class来定义。
b,代码严格区分大小写。
c,Java中的标识符与关键字。
Java中的包、类、方法、参数和变量的名字，可由任意顺序的大小写字母、
数字、下划线(_)和美元符号($)组成，但标识符不能以数字开头，不能是
关键字。
java中的关键字
abstract do implement private
this boolean double import
protected throw break else
fianlly public throws try
byte int return transient
case interface short true
catch final long static
char native strictfp void
class float new super
continue null switch while
default if package volatile
synchronized for extends false
instanceof
d,代码的阅读性与注释的作用。
e,main函数的作用。
程序的入口
保证程序的独立运行
被JVM调用
<2>变量以及数据类型
A，常量
常量：程序中固定的，不变化的量。比如：整数，小数等。
整数进制：（计算机存储数据的方式）为什么要出现这么多进制？
为了更方便的操作二进制数据。
二进制：0 1
八进制：0～7 0开头例：024（不太常用）
十六进制：0～9 A~F 0x开头例：0x2a4e
十进制：0～9
规律：进制越大，数的表示长度越短。
浮点型：就是小数，根据精确度不同，分单精度和双精度
布尔型：true false
字符型：用单引号表示如，‘a’‘1’
字符串型：用双引号表示“abc”“a”和‘a’区别？
空常量：null，表示对象的引用为空
B，变量
B1,变量的概念：
a,内存中的一个存储区域
b,该区域有自己的名称（变量名）和类型（数据类型）
c,该区域的数据可以在同一类型范围内不断变化
B2，为什么要定义变量：
用来不断的存放同一类型的常量，并可以重复使用B3，使用变量注意：
a,变量的作用范围（一对{}之间有效）
b,初始化值
c,定义变量的格式：
d,数据类型变量名= 初始化值；
注：格式是固定的，记住格式，以不变应万变。
自动类型转换（也叫隐式类型转换）
强制类型转换（也叫显式类型转换）
类型转换的原理
什么时候要用强制类型转换
表达式的数据类型自动提升
所有的byte型、short型和char的值将被提升到int型。
如果一个操作数是long型，计算结果就是long型；
如果一个操作数是float型，计算结果就是float型；
如果一个操作数是double型，计算结果就是double型。
<3>运算符(重点：continue和break)
A,算术运算符
只需注意一下几点就行了：
a,+：
正号，如+3，结果为3；
加号，如3+3，结果为6；
字符串相加,如“He”+“llo”，结果为“Hello”
b,如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。
但被模数是负数就另当别论。
c,对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
B,赋值运算符
= , +=, -=, *=, /=, %=
C,比较运算符
注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=”。
D,逻辑运算符
a,逻辑运算符用于连接布尔型表达式，在Java中不可以写成3
b,“&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；
双与时，如果左边为真，右边参与运算，如果左边为假，则右边不参与运算。
d,“|”和“||”的区别同理，双或时，左边为真右边不参与运算。
e,“^ ”异或与“|”或得不同之处是：当左右都为true时，结果为false。
E,移位运算符(移位运算对于数值运算是最快的。)
<<：左移
>>：右移
>>>：无符号右移
技巧：二进制1就是true，0就是false。
<4>语句
每一种高级语言都会有语句，让计算机实现一些更为复杂的事情，
A，判断语句
if语句
三种格式：
1，if(条件表达式)
{
执行语句；
}
2，if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
简写形式：变量=（条件表示式）?表达式1:表达式2;（必须有结果）
3， if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
注：
a,每一种格式都是单条语句。
b,第二种格式与简写格式的区别：简写格式运算完要有值出现。好处是可以写在其他表达式中。
c,条件表达式无论写成什么样子，只看最终的结构是否是true或false;
B，选择语句
switch语句
格式：（对于值的结果是比较固定的比较情况）
switch(表达式)
{
case 取值1:
执行语句；
break；（语句执行完便跳出循环）
case 取值2:
执行语句；
break；
…...
default:（相当于else语句）
执行语句；
break；
}
注：
a,switch语句选择的类型只有四种：byte，short，int ，char。
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
C，循环语句
1，while语句(如果定义完语句和变量，执行完后还需要操作的时候)
格式：
while(条件表达式)
{
执行语句；
}
2，do while语句
格式：
do
{
执行语句；
}
while(条件表达式);
注意：do while特点是条件无论是否满足，循环体至少被执行一次。
3，格式:(循环中需要增量控制循环，增量定义在for语句中，for 执行完之后能够释放。)
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
执行顺序：
初始化语句-->条件判断-->循环体-->循环后的操作表达式-->条件；
注：
a,for里面的两个表达式运行的顺序，初始化表达式只读一次，
判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，
接着继续判断循环条件，重复整个过程，直到条件不满足为止。
b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束时就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
c,最简单无限循环格式：while(true) , for(;;),无限循环存在的原因
是并不知道循环多少次，而是根据某些条件，来控制循环。
D，跳转控制语句（重点和难点）
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注：
a,这两个语句离开应用范围，存在是没有意义的。
b,这两个语句单独存在下面都不可以有语句，因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现，可以让这两个语句作用于指定的范围。
<5>函数（同类型功能的抽象）
a,什么是函数？
函数就是程序中一段独立的小程序.
(对多个因参数不同而结果不同但功能相似的“功能”的抽象) b,Java中函数的格式：（与主函数定义在同一个了类中）
返回值类型函数名(参数类型形式参数1，参数类型形式参数2，……)
{
执行语句;
return 返回值;
}
c,函数特点
它是程序中一段独立的小程序。
它可以实现独立的功能。
它只有被调用才会执行。
它可以被重复使用。
d,函数重载
1，概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
2，存在的原因：
方便于阅读，优化了程序设计。
3，特点：
与返回值类型无关，只看参数列表。
<6>数组（同类型数据的集合）
1，概念：同一种类型数据的集合。
2，数组的好处：可以自动给元素从0开始编号，方便操作这些元素。
3，数组的格式：
元素类型[ ] 数组名= new 元素类型[元素个数或数组长度];
例：int[] arr = new int[5];
4，另一种初始化方式：
元素类型[ ] 数组名= {元素，元素，……};（省略数组名）
例：int[] arr = new int[]{3,5,1,7};
5, 数组中常见问题：
数组角标越界异常（ArrayIndexOutOfBoundsException）
空指针异常（NullPointerException）
6，二维数组
第一种形式
int[ ][ ] arr = new int[3][2];
定义了一个二维数组，其中有三个一维数组，每一个一维数组中有一有2个元素。
或者：
int[ ][ ] arr = new int[3][ ];
第二种形式
int[ ] [ ] arr = {{3,1,5},{2,6},{8}};
元素值5的表示方式为：arr[0][2] = 5;
第二个一维数组的长度表示方式：arr[1].length = 2;
对二维数组的遍历使用for的嵌套循环。
对于其他多维数组，几维就用几层for嵌套，但通常情况数组最多用到三维，因为效率已经大大降低了，也不方便于阅读。
<7>内存特点
开辟不同内存空间是为了对每一片内存中的数据都有不同的处理方式，提高效率。
a, 栈内存的特点：
存储局部变量，空间不用时自动释放内存。
b, 堆内存的特点：
1,存储数组和对象，通过new关键字建立的实体都存放在堆内存当中。
2,实体都有一个内存地址值。
3,对内存中的变量都有默认初始化值。
4,垃圾回收机制，Java特有的内存管理机制，在不定时的时间内将垃圾清除释放空间。
第二部分：面向对象
1,面向对象。
a,面向对象是一种思想，一种符合现实生活中思考习惯思想。
举例：面试官，您是就是在用面向对象的思想思考问题，你在找会编程的对象。并指挥他们为公司创造效益。那么我就是那个对象。
b,面向对象将复杂的事情简单化，它也有弊端，将简单事情复杂化。所以面向过程还存在。
c,让程序员的角色在做着转变，从执行者转变成指挥者。
2，面向对象的特征：
封装，继承，多态。
3，类和对象什么关系呢？
类：是用java语言对事物的描述。
对象：被描述的事物实实在在存在的个体。
4，对象的定义：
类名变量名= new 类名();//Car c = new Car();
那么c就是类类型变量，类类型变量一定指向对象，或者接收对象。
如果使用对象中的内容呢？
通过对象.对象成员。
描述类其实就是在定义类中的成员。成员包括成员变量和成员函数。
5，匿名对象的应用。
对象也可以不用定义名称。那么它有自己的使用场景。
1，如果只对对象的方法进行一次调用的时候，可以使用匿名对象。
2，匿名对象可以作为实际参数进行传递。
匿名对象其实就是对象定义的简化形式。
6，封装：把属性隐藏的做法就是一种封装形式。
因为成员变量在被对象调用时赋了不符合现实事物的值，比如年龄是负数。
将年龄属性进行隐藏，对外提供两个规范方法set get来访问age。
提供方法有什么好处呢？可以在方法体内加入逻辑判断。增强程序的健壮性。
那么封装其实就是在隐藏实现细节。
封装体包含：
函数、类、包、框架。
封装的好处：
提高了安全性，便于用户的使用。
private关键字可以修饰成员，权限最小，只在本类中有效。
通常成员私有化，通过set get来访问。
不需要对外暴露的都隐藏起来。
注意：私有仅仅是封装的一种体现形式而已。
7，构造函数。
在定义上和一般方法有些不一样。
a,函数的名字和类一样。
b,函数的返回值类型不需要定义。
c,函数的内部不需要写return语句。
有什么用呢？
构造函数可以对对象进行初始化。就是说实体一建立，该做哪些事情由构造函数来定义。
构造函数和一般方法在运行上有不同吗？
构造函数在对象一建立就运行了。
一般方法是，需要对象调用才执行。
构造函数可以定义多个吗?
可以，因为对象的初始化有可能不同。
多个构造函数是以重载的形式体现的。
注意：
如果在class定义的类中没有定义过构造函数的话。
jvm会自动的给这个类加入一个空参数的构造函数。
小知识点：默认构造函数的权限和类一致。
8，this关键字
this：它代表一个对象，代表一个this所在函数所属对象的引用。
大白话：哪个对象调用了this所在的函数。this就代表哪个对象。
什么时候用this？
当描述功能的时候功能内部又使用到了本类对象，那么就用this来表示这个对象。
class Person
{
private int age;
Person(int age)
{
this.age = age;
}
public boolean comp(Person p)
{
return this.age == p.age;
}
}
基于以上this的特点。
就可以有一个应用，区分成员变量和局部变量重名的情况。
https://www.doczj.com/doc/dd14200106.html, = name;
this的另外一个应用：
this语句。
当构造函数之间进行调用的时候，可以使用this语句来完成。
注意：this语句必须放在构造函数的第一行,因为初始化的动作一定要先完成。
class Person
{
private String name;
private int age;
Person()
{
}
Person(String name)
{
this();
}
Person(String name,int age)
{
//this("haha");
https://www.doczj.com/doc/dd14200106.html, = name;
}
/*
Person p = new Person();
Person p1 = new Person("lisi");
Person p2 = new Person("qq",30);
*/
}
9,static关键字
需要被所有对象使用的成员可以用该关键字来修饰。
a，静态可以修饰成员。包括成员变量和成员函数。
b，静态随着类的加载而加载，随着类的消失而消失，说明其生命周期最长。
c，优先于对象存在。
d，被静态修饰的成员被对象所共享。
e，静态可以直接被类名所调用。
静态使用需要的注意的细节：
a，静态方法只能访问静态成员。非静态方法可以访问静态也可以访问非静态。
b，静态方法中不可以书写this，super关键字。
c，主函数是静态的。
static代码块。
static{}
特点：
随着类的加载而执行。只执行一次。优先于主函数执行。
作用：
给类进行初始化。
10，单例设计模式。
设计模式：解决某一类问题行之有效的方法。
单例解决什么问题？
保证类在内存中的对象唯一性。
场景应用：
当多个访问需要同一个数据区域时。如：超人。
可以通过三部来完成：
1，将构造函数私有化。（不让外界建立该类对象。）
2，定义一个私有并静态的最终本类对象。
3，定义一个公有并静态的方法让外界获取该类的对象。
两种方式：
class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getSingle()
{
return s;
}
}
{
private static final Single s = null;
private Single(){}
public static Single getSingle()
{
if(s==null)
s = new Single();
return s;
}
}
11，A，内部类：
其实就是在类的里面再定义类，可以定义多个。
内部类的出现访问上有了特点：
内部类可以直接访问外部类中的成员。
外部类要想访问内部类必须要建立内部类的对象。
之所以内部可以直接访问外部的成员，那是因为：内部类持有了外部类的引用。
外部类名.this。
什么时候用内部类呢？
通常用于设计，描述事物时，事物的内部还有具体事物，可以通过设计内部类的形式来完成。
内部类如果定义在成员位置上，可以被成员修饰符所修饰。
内部类定义在局部位置上，除了直接访问外部类的成员，也可以直接访问局部中被final修饰的变量。
B，匿名内部类：
特点：匿名内部类是内部类的简化形式。
前提：内部类需要继承或者实现一个外部类或者接口。
实质：其实就是一个类或者接口的匿名子类对象，这个对象有点胖。
什么时候用：
当函数的参数是接口类型，并且接口中的方法只有三个以内。
那么这时就可以传递一个匿名内部类。
class Outer
{
public void function()
{
new Object()
{
public void show()
{
System.out.println("hahah");
}
}.show();
}
}
class OuterDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.function();
}
}
---------------------------------------------------------
12，javadoc。制作程序的帮助文档。
其实就是通过javadoc工具将对外提供的功能以及功能所对应的文档注释进行提取，生成网页文档。
javadoc -d myhelp -author -version Tool.java
注意：该类一定要公有。public
@param arr 描述参数。
@return 描述返回值。
13，继承extends：
好处：提高代码的复用性。
让类与类之间产生了关系。因为关系出现，才出现了多态。
java只支持单继承，不支持多继承。为什么不支持多继承？
因为多个父类有相同方法但方法体不同时，就会出现安全隐患。
但是java支持多层继承。
在继承系统中，顶层类中定义的该体系中最共性的方法。
该句说明的是：1，顶层类是由其他类向上抽取而来的。
2，如果要使用该继承体系中的基本功能，只要查阅顶层类即可。
3，通常建立最子类对象。使用该体系中的基本功能。
子父类出现后，类中成员的变化。
当子父类中出现一模一样的方法时，出现一个操作：覆盖。
子类可以继承父类已有功能，但是可以建立子类该功能具体内容。class Demo
{
void show()
{
System.out.println("Demo");
}
}
class Main
{
public static void main(String[] args)
{
Demo d = new SubDemo();
d.show();
//SubDemo sd = new SubDemo();
//sd.show();
}
}
//一年后。
class SubDemo extends Demo
{
void show()
{
System.out.println("subdemo");
}
}
覆盖注意事项：
1，覆盖时，子类权限必须大于等于父类权限。
2，静态覆盖静态，或者被静态覆盖。
继承出现后出现一个关键字：super。
super：代表的是父类对象引用。用法和this一致。
------
子类的实例化过程。
子类中所有的构造函数默认都会去访问父类中空参数的构造函数。
为什么呢？
因为子类的构造函数第一行有一句隐式语句super().
也因为子类获取到了父类的成员，所以要先看父类是如何对这些成员进行初始化的。
那么如果父类中没有空参数构造函数，子类构造函数中必须通过this或者super语句指定要访问的构造函数。
继承用于程序设计。为了让类与类产生关系。
什么时候用继承呢？出现所属关系的时候。所属关系如何判断呢？
该类是否应该具备另一个类的所有功能。儿子和父亲例子。
注意：不要为了获取其他的类的功能而继承。陌生人的iphone手机。
-------------------------------------------------------
14，final
a,final 可以修饰类，方法，变量。
b,final修饰的类不能被继承。但是可以继承其他类。有什么意义？
保证该类的功能不会因为子类的重写发生变化。
c,final修饰的方法不能被覆盖。可以覆盖其他方法。
d,final修饰的变量是一个常量，只能给其赋值一次。
被final修饰的变量出现，其实就是为了给某些常量值起个阅读性更强的名称，并将该名称和值固定。
e,内部类可以访问被final修饰的局部变量。
-------------------------------------------------------
15，抽象类
特点：
a，其中可以存放抽象方法。
b，抽象类和抽象方法都需要被abstract关键字修饰。
c，抽象类不可以用new建立对象，因为调用抽象方法没意义。
d，抽象类的子类必须覆盖父类中所有的抽象方法后，才可以进行实例化。
否则，该子类还是一个抽象类。
抽象方法：
只需方法声明，不需要方法主体。所以用;结束。
abstract class Demo
{
abstract void show();
}
抽象类或者抽象方法是怎么出现的呢？
其实就是事物不断向上抽取的结果。
事物都具备共性功能，但是功能的内容却是不同，那么这时只抽取了功能的声明，
没有抽取功能的主体。这时该功能就是抽象的。抽象方法一定存放在抽象类中。
好处：
抽象类的抽象方法可以强制子类去做某些事。
学员的例子。
抽象的出现引发的几个概念。
1，抽象类一定是个父类。
2，abstract和final，static，private不可以同时存在。
3，抽象类中可以没有抽象方法，该类存在的意义是：不让其建立对象。
其实：抽象类一般类没太大的区别，仅仅是可以存放抽象方法而已。
那么在定义抽象类的时候和定一个一般类是一样，都是按照基本描述思想在描述事物。
-----------------------------------------------
16，接口interface
你可以理解为，接口是一个特殊的抽象类，但是这仅仅是刚开始接触接口的印象。
特点：
1，接口是对外暴露的规则。
2，接口是功能的扩展。
3，接口的出现降低了耦合性。
4，接口可以多实现，多实现是多继承机制在java中的的体现。
例子：主板PCI。插座。笔记本电脑。
接口定义时有什么特点：
接口中常定义的内容有常量和抽象方法。
而且这成员有自己固定修饰符。
常量：public static final
方法：public abstract
接口出现还有一个好处：
一个类在继承另一个类的同时可以实现一个或者多个接口。
学员的例子。有一部分学生抽烟，定义一个抽烟接口。
class ZhangSan extends XueYuan implements ChouYan
{}
类与类之间是继承关系。
类与接口之间是实现关系。
接口与接口之间是继承关系。而且接口支持多继承。
----------------------------------------------------------------
17，进制转换：该程序只要讲解：
a，查表思想。就是将有限的元素都列出来临时存放。
b，对数组的指针思想进行应用。
c，练习了一下二进制，以及& >>>
class BinTrans
{
二进制和十六进制它们的转换方式都差不多。
1，定一个表。
2，定一个临时存储容器。
3，获取该十进制在内存中的二进制位。转成二进制一位一位获取，转成十六进制4位4位获取。
4，通过获取到的值查表，将表中的内容存入到临时容器中。
5，继续获取下一位或者下4位，通过无符号右移>>>。
因为进制的不同，&运算的基数不确定，而且右移的位数也不确定。
private static String trans(int num,int base,int offset)
{
if(num==0)
return "0";
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while(num!=0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
return new String(arr,pos,arr.length-pos);
}
public static String toBin(int num)
{
return trans(num,1,1);
}
public static String toHex(int num)
{
return trans(num,15,4);
}
}
18，多态：
好处：增强了程序的扩展性。
按照面向对象的思想，指挥对象做事情。可是对象多了以后，挨个指挥对象就变的很复杂。为了将将其过程简单化，那么，找到这些对象共有类型。只要指挥这些对象共有类型即可。
如：张三.学习().李四.学习().这样过于麻烦。有了多态以后，学员.学习().
前提：类与类之间要有关系。(继承关系，实现关系)
通常需要覆盖操作，这样才可以提高扩展性，在前期的设计中使用后期的内容。
interface PCI
{
void open();
}
class MainBoard
{
void usePCI(PCI p)//PCI p = new NetCard();
{
p.open();
}
}
public static void main(String[] args)
{
MainBoard m = new MainBoard();
https://www.doczj.com/doc/dd14200106.html,ePCI(new NetCard());
MainBoard m = new MainBoard();
https://www.doczj.com/doc/dd14200106.html,ePCI(new SoundCard());
}
//一年后。
interface PCI2 extends PCI
{
void close();
}
class NetCard implements PCI
{
public void open()
{
System.out.println("netCard open");
}
class SoundCard implements PCI
{
public void open()
{
System.out.println("Soundcard open");
}
}
成员上的变化：
成员函数：编译时，看的是引用型变量所属的类或者接口中是否有所调