1.java程序设计基础
1.1 标识符、关键字及数据类型
标识符：程序中的实体—变量、常量、方法、类和对象等的名称叫做标识符。
关键字：关键字又称作保留字，它们具有专门的意义和用途，不能当作一般的标识符使用。
数据类型：Java语言提供了丰富的数据类型，分为基本类型（又叫做原始类型）和引用类型两大类。
1.1.1 标识符
程序中所用到的每一个变量、方法、类和对象的名称都是标识符（Identifier），都应该有相应的名称作为标识。简单地说，标识符就是一个名称。
Java语言的标识符命名规则
由英文字母A～Z或a～z、下划线（_）、美元符号（$）和数字0～9组成，还可以包括中文字符等其他Unicode8.0字符集，开头必须是英文字母、下划线或美元符号（$）。 标识符区分大小写。如sum、Sum和SUM是三个不同的标识符。 不允许使用Java关键字（后面要介绍）来命名。 标识符没有长度限制，但我们不建议使用太长的标识符. 标识符命名原则应以直观且易于拼读为宜，即做到“见名知意” 。 Java中标识符命名约定：常量用大写字母，变量用小写字母开始，类以大写字母开始。 标识符不能包含空格，只能包含美元符（$）,不能包含#、&、@等其它特殊字符。
2.类和对象
2.1 类的创建
package sample;
class StringTest{
private String s;
public void printString(){
System.out.println(s);
}
public void changeString(String str){
s = str;
}
public static void main(String[] args){
StringTest st = new StringTest ();
st.changeString("Hello Lixin");
st.printString();
}
}
2.2 类的定义
基本语法如下： [类修饰符] class 类名称 [extends 父类名称][implements 接口名称列表] { 成员变量定义及初始化； 方法定义及方法体； } 类的定义由类声明和类体组成。其中，类声明包含关键字class、类名称及类的属性。 类的修饰符有：public、abstract 、final和friendly四种，默认方式为friendly。
2.3 成员变量的定义及修饰字
成员变量：指类的一些属性定义，标志类的静态特征，它的基本语法如下： [变量修饰符] 变量数据类型 变量名1，变量名2[=变量初值]…; 对于一个成员变量，可以有访问说明符有public、private和protected三种： （1）public：省略时默认为公有类型，可以由外部对象进行访问。 （2）private：私有类型，只允许在类内部的方法中使用，若从外部访问，必须通过构造函数间接进行。 （3）Protected：受保护类型，子类访问受到限制。
2.4 方法的定义及修饰字
基本格式如下： [方法修饰符] 返回类型 方法名称（参数1,参数2,…） [throws 异常类] { 方法体 } 其中，方法修饰符有：[public | protected | private ] [static] [final | abstract] [native] [synchronized]。
2.5 方法的参数传递
2.5.1 参数的传递方式
package sample;
class ParamPass {
void add(int i) {
i += 5;
}
public static void main(String args[]) {
int a = 10;
System.out.println("a and b before call: " +a );
ParamPass ob=new ParamPass();
ob.add(a);
System.out.println("a and b after call: " +a );
}
}
输出如下
a and b before call: 10
a and b after call: 10
2.5.2 参数的引用方式
package sample;
public class ParamPass {
void changeArray(int[] array) {
array[0] = 100;
}
public static void main(String args[]) {
int array[] = new int[10];
System.out.println("Before: Array[0] = " + array[0]);
ParamPass ob=new ParamPass();
ob.changeArray(array);
System.out.println("After: Array[0] = " + array[0]);
}
}
输出如下
Before: Array[0] = 0
After: Array[0] = 100
2.6 类的实例化
2.6.1 创建对象
对象的生成包括声明、实例化和初始化。基本语法如下： 类名称 对象名 //声明对象 对象名= new 类名（[<参数列表>]）； //创建对象
2.6.2 对象成员的使用
对象的使用是通过运算符"."实现对变量的访问和方法的调用。变量和方法可以通过设定访问权限来限制其它对象对它的访问。基本语法如下： 对象名.成员变量名 对象名.成员方法名（[<参数列表>]）；
【例】类的定义及成员方法的使用
package sample;
public class Person
{
int age;
public void pout()
{
System.out.println("My age is" + age);
}
public static void main(String args[])
{
Person p1 = new Person();
Person p2 = new Person();
p1.age = 20;
p2.age=18;
p1.pout();
p2.pout();
}
}
2.7 构造方法
Java中的每个类都有构造方法，用来初始化该类的一个新对象。构造方法（Constructor）是一种特殊的方法。构造方法的名称必须和类名相同，为公有类型，无返回值，用来从类实例中访问类时初始化此类的私有变量。 当创建对象时，由new运算符调用默认构造方法（没有参数的构造方法）。但是特别要注意的是，如果程序中已经定义了构造方法，Java就不会再生成默认构造方法了。
2.8 继承的概念
所谓继承就是保持已有类的特性而构造新类的过程。继承是子类利用父类中定义的方法和变量，就像它们属于子类本身一样。特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。例如：如汽车与小汽车；教育工作者与教师。当一个类拥有另一个类的所有数据和操作时，就称这两个类之间存在着继承关系。
Java中不支持类之间的多重继承（注：Java支持接口之间的多重继承），即不允许一个子类继承多个父类。这是因为多重继承带来了许多必须处理的问题。多重继承只对编程人员有益，却增加了编译器和运行环境的负担。
2.9 多态性
多态是指一个方法只能有一个名称,但可以有许多形态,也就是程序中可以定义多个同名的方法，用“一个接口，多个方法”来描述，可以通过方法的参数和类型引用实现。
多态的实现
package sample;
public class ShapeTest {
public ShapeTest() { }
public static void main(String[] args) {
Shape[] s={new Shape(1,4),
new Rectangle(1,2,3,4),
new Circle(2,3,5)};
for(int k = 0; k < s.length; k++){
s[k].draw();
}
}
}
class Shape{
protected int x;
protected int y;
public Shape(){ }
public Shape(int x, int y){
this.x = x;
this.y = y;
}
public void draw(){System.out.println("This is a test in shape.");}
}
class Rectangle extends Shape{
private int heigth;
private int weight;
public Rectangle(int x, int y, int w, int h){
super(x,y);
this.weight = w;
this.heigth = h;
}
public void draw(){System.out.println("This is a test in Rectangle.");}
}
class Circle extends Shape{
private int r;
public Circle(int x, int y, int r){
super(x,y);
this.r = r;
}
public void draw(){System.out.println("This is a test in Circle.");}
}
3.Java面向对象高级特性
3.1 静态（static）变量、方法和初始化块
类定义的内容主要包括成员变量、成员方法、构造方法和初始化块等，在定义方法和变量时，可以在之前用static修饰，表明它们是属于类的，称为静态方法（类方法）或静态变量（类变量）。
3.1.1 静态（static）变量
用static修饰的成员变量称为静态变量（类变量），若无static修饰，则是实例变量。静态变量或类变量是一种全局变量，它属于某个类，不属于某个对象实例，是在各对象实例间共享。如果想访问静态变量可以直接通过类名来访问，可以不通过实例化访问它们。而实例变量就必须通过对象实例来访问它们。
class Example05_1 {
int a = 1;
static int b = 2;
}
class Example05_1Demo {
public static void main(String args[]) {
System.out.println("b=" + Example05_1.b);
Example05_1.b *= 2;
Example05_1 o1 = new Example05_1 ();
o1.a = 10;
System.out.println("o1.a="+ o1.a);
System.out.println("b="+ o1.b);
Example05_1 o2=new Example05_1 ();
System.out.println("o2.a=" + o2.a);
System.out.println("b="+ o2.b);
}
}
输出如下
b=2
o1.a=10
b=4
o2.a=1
b=4
3.1.2 静态（static）方法
同样，static修饰的成员方法称为静态方法（类方法），调用静态方法可以通过类名来调用，即不用实例化即可调用它们。 1、实例变量或者类变量在定义初始化时，都不能超前引用； 2、实例方法既可以使用实例变量，又可以使用静态变量；而静态方法只能使用静态变量，不能直接使用实例变量。
3.2 最终（final）类、变量和方法
final在类之前，表示该类不能被继承，即final类不能作为父类，任何final类中的方法自动成为final方法，一个类不能同时用abstract和final修饰； final在方法之前，防止该方法被覆盖，final方法不能被重写，因此，如果你在子类中有一个同样签名的方法的话，你会得到一个编译时错误 final在变量之前，定义一个常量，一个final变量的值不能被改变，并且必须在一定的时刻赋值。
3.3 抽象方法与抽象类
Java中可以定义一些不含方法体的方法，它的方法体的实现交给该类的子类根据自己的情况去实现，这样的方法就是abstract修饰符修饰的抽象方法，包含抽象方法的类就叫做抽象类，也要用abstract修饰符修饰。
3.3.1 抽象方法
用abstract来修饰一个方法时，该方法叫做抽象方法。形式如下： abstract [修饰符] <返回类型> 方法名称([参数表]); 抽象方法并不提供实现，即方法名称后面只有小括号而没有大括号的方法实现。包含抽象方法的类必须声明为抽象类。抽象超类的所有具体子类都必须为超类的抽象方法提供具体实现。
3.3.2 抽象类
抽象类通常包含一个或多个抽象方法（静态方法不能为抽象方法）。 抽象类必须被继承，抽象方法必须被重写； 抽象类不能被直接实例化。因此，它一般作为其他类的超类，使用抽象超类来声明变量，用以保存抽象类所派生的任何具体类的对象的引用。程序通常使用这种变量来多态地操作子类对象。与final类正好相反； 抽象方法只需声明，而无需实现。定义了抽象方法的类必须是用abstract修饰的抽象类。
3.4 接口（interface）
通过接口可以实现不相关类的相同行为，而无需考虑这些类之间的层次关系； 通过接口可以指明多个类需要实现的方法； 通过接口可以了解对象的交互界面，而无需了解对象所对应的类。
3.4.1 接口的定义
在java中，接口是由一些常量和抽象方法所组成，接口中也只能包含这两种东西，一个接口的声明跟类的声明是一样的，只不过把class关键字换成了interface
3.4.2 接口的实现
实现接口我们使用implements关键字。在子类中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法，否则子类就变为抽象类了。
1、接口中的常量必须是用public static final修饰；
2、接口中的方法必须用public static修饰；
3.5 内部类
Inner Class按照字面意思就是内部类的意思，简单说就是嵌套在另一个类中定义的类就是内部类（Inner Classes）。包含内部类的类叫做外部类。
Inner Class可以直接访问外部类的成员。因为Inner Class在外部类中，理所当然可以访问任何的成员，包括声明为private的成员。