final修饰符、抽象类、接口、多态、内部类的简单小结

final修饰符

可以修饰类，方法，变量。

1， 当修饰类时，该类表示最终类，不能被其他类所继承。

2， 当修饰方法时，该方法不能被覆盖。

3， 当修饰变量时，该变量不能被修改。

public staticfinal double PI =3.1415;全局常量

抽象类 abstract

当很多子类中有相同的方法时，可以进行向上抽取，形成抽象方法。抽象方法没有函数体，函数用abstract关键字修饰。抽象方法必须存在于抽象类中。抽象类中可以有非抽象方法。

特点：

l 方法只有声明而没有实现时，该方法就是抽象方法，抽象方法必须被abstract关键字修饰，且该类也为抽象类，必须被abstract修饰。

l 抽象类不能被实例化，因为调用抽象方法，没有意义。

l 只有其子类实现了他的所有抽象方法，子类才能被实例化，如果子类没有实现所有的抽象方法，这子类也为抽象类。

Abstract 不可以和那些关键字组合

1，
private 私有了不能被子类发现。

2，
static 静态了直接类调用没意义

3，
final 既要被覆盖，又不能被覆盖，矛盾。

Employee.class=========================================================================

package EmployeeDemo;

public abstract class Employee {
private int id;
private	String name;
private double pay;

protected int getId() {
return id;
}

protected void setId(int id) {
this.id = id;
}

protected String getName() {
return name;
}

protected void setName(String name) {
this.name = name;
}

protected double getPay() {
return pay;
}

protected void setPay(double pay) {
this.pay = pay;
}

Employee(int id, String name, double pay) {
this.id = id;
this.name = name;
this.pay = pay;
}

public abstract void work();
}

Manager.class==================================================================================

package EmployeeDemo;

public class Manager extends Employee {

private double bonus;
public Manager(int id, String name, double pay,double bouns) {
super(id, name, pay);
this.bonus = bouns;

}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println(this.getName()+"'s work is Manage...");
}

}

Programmer.class=========================================================================

package EmployeeDemo;
public class Programmer extends Employee {
public Programmer(int id, String name, double pay) {
super(id, name, pay);
}
@Override
public void work() {
System.out.println(this.getName()+"'s work is codeing...");
}
}

EmployeeDemo========================================================

package EmployeeDemo;

public class EmployeeDemo {

/**
* @param args
*/
public static void main(String[] args) {
Programmer p = new Programmer(01, "小明", 8000);
Manager m = new Manager(02, "小咪", 7000,200);
p.work();
m.work();
}
}

接口 interface implements（实现）

接口中的方法全部必须是抽象方法。成员必须是全局常量

定义接口使用的是 interface而不是class

接口中常用的成员都有固定的修饰符

全局常量：public static final

抽象方法：public abstract

类与类之间是继承关系。类与接口之间是实现关系。

接口不可以实例化，只有子类实现了接口的所有抽象方法，子类才可以实例化，如果子类没有实现所有的抽象方法，则子类为抽象类，也不能实例化。

接口和实现接口的类，以及实现接口类的对象都可以直接调用常量。

Java 没多继承，但实现了多继承。一个类可以实现多个接口。

接口和接口之间可以多继承。

多态

//一种类型（普通类、抽象类、接口）可有多种形态
public static void main(String[] args) {
Animal a = new Cat();
Animal b = new Dog();
//多态，一种类型可有多种形态
//向下转型必须转成new出来的类型 如 ClassA b = new ClassC();   ClassC c = C(b);
Dog d = (Dog)b;//向下转型，向下转型可以使转型后的类的特有方法有效。
((Cat) a).cathMouse(); //right 向下转型
//		Cat cc = (Cat)b;   //转换异常！java.lang.ClassCastException   DuoTaiDemo.Dog cannot be cast to DuoTaiDemo.Cat
//		a.cathMouse();  error
a.eat();//right, 可以调用共有的的方法。
d.lookHome();//转型后 特有方法有效
}
向上转型 ：
Animal a = new Cat();
Animal b = new Dog();
向下转型：
Dog d = (Dog)b;//向下转型，向下转型可以使转型后的类的特有方法有效。
((Cat) a).cathMouse(); //right 向下转型

a instancsof A

用于判断 a对象是不是A类型的，是返回true，否则返回false。

多态中成员的特点：（没向下转型）

1， 成员变量

编译运行时都看等号的左边（父类）（在调用时，只有=左边的类型有的成员，才能被调用）

2， 成员方法

a) 编译时看（父类）左边，运行时看右边(子类)。

3， 静态方法

a) 编译运行都看左边

对于静态函数其实不需要定义对象。直接类名调用即可，可以说不牵扯多态

内部类

在分析一个事物时，如果该事物内部还有其他事物时，并且该内部的事物与该事物成员结合紧密，和该事物以外的其他事物联系很少时，可以使用内部类

相当于一种封装

l 在一个类的内部定义的类称为内部类。

l 访问特点

n 内部类可以直接访问外部类的成员，包括私有成员。

n 而外部类要访问内部类的成员必须要建立内部类的对象。

u 需要创建内部类的对象

举例（孙悟空飞进铁扇公主的里边）

可以很方便的访问内部类的成员。而不用通过方法等间接的去调用

修饰符：

当内部类有静态成员则内部类必须被静态修饰，即为静态类

package InnerClassDemo;

/**
*
* 运行后生成三个class文件
*
* Outer.class Outer$Inner.class InnerClassDemo.class
*
*
*/

class Body {
private String breatheOrgan = "嘴";

class Lung// 肺
{
void breathe() {
System.out.println("breathe  with ..." + breatheOrgan);// 内部类可以直接访问外部类的成员
}
}

public void breatheSys() {// 外部类需要访问内部类时必须建立连接
Lung l = new Lung();
l.breathe();
}
}

public class InnerClassDemo {

public static void main(String[] args) {

// Body b = new Body();
// b.breatheSys();
// 在外部直接访问内部类
Body.Lung l = (new Body()).new Lung();
l.breathe();
}
}