类的定义

（1）类的成员变量的定义

（2）当一个类的定义存在后，可以使用new运算创建对象，类的实例化

new 类名();

JVM为该对象开辟了内存空间，该对象中存储有成员变量；

（3）成员变量的类型

1.1   引用类型变量

除了8种基本类型，用类名（接口，数组）声明的变量称为引用类型变量，简称引用；

引用类型变量中存储的是某个对象在内存中的地址信息。引用的功能在于访问对象；

引用类型变量按照如下方式声明：

类名                                          引用类型变量名

Point P =new Point();

new Point()创建对象；Point P引用类型变量；

用某个类名声明的引用类型变量可以存储该类对象的地址信息，通常称为“指向该类的对象”，当一个引用类型变量指向该类的对象时，就可以通过这个变量对对象实施的访问

new 类名()创建的堆内存中，

引用类型变量存储在“栈”中，堆内存中的地址赋值等p；

1.2   成员方法

class 类名{

返回值类型方法名称（参数列表）{

}

}

1.3  JVM的内存结构

方法区：

Java程序运行时，首先通过类装载器装入类文件的字节码信息，经过解析装入方法区；

栈：

栈用于存放程序运行过程中的所有局部变量。JVM会为每一个方法的调用在栈中分配一个对应的空间，称为方法的栈帧。一个栈帧对应一个正在调用的方法，栈帧中存储了改方法的参数、局部变量；当某一个方法调用完成后，其对应的栈帧将被清楚

堆：

JVM的内存空间中堆：用于存储使用new关键字创建的对象；

1.4      方法的重载

方法的调用必须通过某个对象的引用；

Java中允许多个方法的名称相同，但是参数列表不同，称为方法重载overload;

编译器在编译时回根据其参数的不同，绑定到不同的方法；

1.5  this关键字

在成员方法中，可以同this关键字表示“调用该方法的那个对象”，this.成员变量

一个类可以创建对个对象，存储在堆中不同的位置，但是成员方法只有一份，存储于方法区中；

调用成员方法的时候，将实例化的某个对象，传递给方法的this

1.6     
null关键字

当某个引用类型为null时候，调用成员变量或者成员方法，会产生NullPointerException;异常

1.7      构造方法

java语言中通过构造方法实现了对成员变量的初始化；构造方法在类中定义；

构造方法的名称必须和类名同名；构造方法没有返回值，但是不能写void;

经常使用new对构造方法来对成员变量进行初始化；

构造方法的重载

在创建对象时候，java编译器会根据不同的参数调用不同的构造方法；

2      类的继承

extends关键字可以实现类的继承

子类可以继承父类的成员变量和成员方法，同时可以定义自己的成员变量和方法；

子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量；如果子类的构造方法中没有调用父类的构造方法，JAVA编译器会自动的加入对父类无参的构造方法的调用；

instanceof关键字

if(shape instanceof circle)判断shape引用类型指向的对象是否为circle类型；

2.1 方法的重写Overwrite

子类可以重写继承自父类的方法（方法名和参数列表和父类相同）；但是方法的实现不同；当子类对象的重写方法被调用时候，运行的是子类重写后的版本；

2.2 重写和重载的区别

重载，在编译期间根据参数变量的类型判断调用哪个方法（方法区选择方法）；

重写，在运行期间根据引用类型变量执行的实际对象类型调用方法(方法区中方法选择不同的堆栈对象);

3       访问控制

private修饰的成员变量和成员方法，仅仅只能在本类中调用；

public 修饰的成员变量和成员方法，可以再任何地方通过对象引用；

public修饰的内容对外提供服务，需要安全稳定；

private的对内封装，减少维护成本

类名的规则：

com.clark.common.lang.StringUtil

组织名称，项目名称，模块名称，包名

3.1 import语句

通过import语句对类的全称进行声明，

在Eclipse中，可以使用ctl+shift+o自动完成import语句；

3.2    protected和默认访问控制

protected修饰的类，可以被子类及同一个包中的类使用；

默认访问控制即不书写任何访问控制符，成员变量和方法可以被同一个包总的类调用；

4      
static和final

4.1 static成员变量

用static修饰的成员变量不属于对象的数据结构；

static成员变量和类的信息一起存储在方法区，而不是在堆中；

static成员变量放在方法区中，所有只有一份，无论创建该类的多少对象；

static变量是属于类的变量，通常可以通过类名的引用static成员；

4.2 static方法

static修饰的方法，不需要针对某些对象进行操作，器运行结果仅仅为输入的参数有关；调用的时候，无需实例化类，仅需要直接调用类名引用就可以；

例如：

double c=Math.sqrt(3.0*3.0+4.0*4.0);

通常的方法：

通用的方法保存在方法区，通常涉及到对具体对象的操作，隐式的需要从堆内存中传递成员对象的引用，还有传递方法的参数；

4.3 static方法的意义

由于static在调用时候，没有具体的对象；因此static方法中不能操作非static成员变量；static方法提供一些工具方法，工厂方法；

4.4 final类

final关键字修饰的类不可以被继承；意义在于，可以控制滥用继承对系统造成的危害；

4.5 final方法

final关键字修饰的方法不可以被重写；放在子类在定义新方法时造成不经意的重写；

4.6     
final成员变量

final关键字修饰成员变量，初始化是赋值，一旦创建即不可改变；

final类型成员变量必须在声明适合初始化；

5       对象数组

所谓对象数组，是对象的元素不是基本类型，是引用类型；

数组中每一个元素都是类的引用类型变量，初始化引用对象数组时，要注意将每一个元素进行实例化；

Point[] ps=new Point[3];

ps[0]=new Point(1,2);

ps[1]=new Point(3,4);

ps[2]=new Point(5,6);

对象数组的初始化和基本类型数组的初始化方式一样，只不过元素的是对象引用类型变量而已；

区别为基本类型数组元素有默认初始化值，但是对象数组元素默认值为null类型；

5.2 数组类型数组（二维数组）

int[][] arr=new int[3][];

arr[0]=new int[2];

arr[1]=new int[3];

arr[2]=new int[2];

arr[1][1]=100

可以理解二维数组，的元素一维数组相当于一个对象，对象里面含有成员变量；

5.3 对象数组和二维数组的初始化

6       抽象类

用abstract关键字修饰的类称为抽象类。抽象类不能实例化，抽象类的意义在于被继承；抽象类为其子类抽象出了公共的部分，通常定义了子类所必须具体实现的抽象方法

6.1 抽象方法

public abstract class Shape{

private int x;

private int y;

public abstract boolean contains(int x,int y);

}

抽象方法仅有方法的定义，没有方法的实现；

6.2 继承抽象类

一个类继承了抽象类必须实现其抽象方法

class Rect extends Shape{

int width,int height;

public Boolean contains(int x,int y){

width=x;

height=y;

}

}

6.3 抽象类的意义；

抽象类的意义是，通过一个程序中，可以传递抽象类的多个多态的个体；

public void print(shape s1,shape s2);

7      
Timer和TimerTask简介

JDK提供的Timer类和TimerTask抽象类可以固定的周期运行某段程序，其中Timer常用的schedule方法如下；

schedule(TimerTask task,long delay,long period);

参数：TimerTask  task是抽象类，定义有抽象的run方法：

public void run();TimerTask封装了需要被周期性执行的任务；

参数：delay表示schedule方法运行后到开始调度任务的延时（单位为毫秒）；

参数：period表示调度任务的周期，即每隔period时间调度一次任务（单位是毫秒）

7.1 Timer常用API

class MyTask extends TimerTask{

@Override

public void run(){

System.out.println(“MyTask”);

}

}

Timer timer=new Timer();

timer.schedule(new MyTask(),1000,500);

timer.cancle();

TimeTask抽象类定义了其子类必须定义实现循环执行Run的方法；使用抽象类，规范了Timer对象的使用；

Timer实现了循环执行，通过TimeTask抽象类封装了循环执行的方法，是为框架；

8       接口

接口也是抽象类，但是接口中只包含抽象方法；和普通抽象类的方法时，不存在其他普通方法，不存在成员变量；接口的定义为：

interface Runner{

//接口中不可以定义成员变量，但是可以定义常量static

public static int DEFAULT_SPEED=100

//接口中只定义没有实现的方法，可以省略public abstract;

public void run();

}

8.1 接口的实现

与继承不同，一个类可以实现多个接口，实现的接口直接用逗号分隔，当然需要实现这些接口中所定义的所有方法

一个类可以通过implements关键字实现接口，一个类实现接口后必须实现该接口中定义的所有方法；

class AmeriacnCurl implements Runner,..{

public void run(){

system.out.pirntln(“run …”);

}

}

Runner runner=new AmericanCurl();

//接口类型变量   ----通过该变量可以调用该接口的定义的方法；

8.2 接口的继承

接口间可以存在继承关系，子接口继承了父接口中定义的所有方法；

interface Runner{

public void run();

}

interface Hunnter extends Runner{

public void hunt();

}

class AmericanCurl implements Humter{

public void run(){};

public void hunt(){.};

}

8.3 多态

9       内部类和匿名类

一个类可以定义在一个类的内部，称为inner内部类，所在类Outer外部类；

内部类，对外部具有可见性，可以调用OUter的成员及方法（包括使用的）；

9.1内部类的原理

Inner对象不能独立于Outer对象而存在；通常将Inner类修饰为private,其对象的创建都在Outer对象中完成。如果想在Outer外部创建Inner对象，必须先创建Outer对象；

Class Outer{

public void start(){

new inner();

}

calss Inner{};

}

创建实例：

Outer outer =new Outer();

Inner inner=outer.new Inner();

outer.start();

Inner对象有个一个隐式的引用指向它的Outer类对象

9.2 内部类的应用

l  当一个类存在的价值仅仅为某一个类服务时候，这个类可以使其成为那个类的内部类；

l  内部类一般情况下对外不可见，除了包含它的外部类外，其他类无法访问到它；

l  内部类可以是方便的访问其外部类的私有属性；

9.3 匿名内部类的定义

如果在一段程序中需要创建一个类的对象，而且创建后，这个类的价值就不存在了，这个类可以不必命名，称之为匿名内部类

例如，通过匿名内部类的形式创建一个实现了ActionListener接口的对象，用于监听button对象的单击事件；

JButton button=new JButton();

button.addActionListenner(new ActionListener(){

public void actonPerformed(ActionEvent e){}

});

匿名内部类应用的接口回调、事件监听等场合；

9.4 回调模式

如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时，会调用参数对象中所实现的方法；