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=========================================================================

[java] view plain copy

1. package EmployeeDemo;  
2.   
3. public abstract class Employee {  
4.     private int id;  
5.     private String name;  
6.     private double pay;  
7.   
8.     protected int getId() {  
9.         return id;  
10.     }  
11.   
12.     protected void setId(int id) {  
13.         this.id = id;  
14.     }  
15.   
16.     protected String getName() {  
17.         return name;  
18.     }  
19.   
20.     protected void setName(String name) {  
21.         this.name = name;  
22.     }  
23.   
24.     protected double getPay() {  
25.         return pay;  
26.     }  
27.   
28.     protected void setPay(double pay) {  
29.         this.pay = pay;  
30.     }  
31.   
32.     Employee(int id, String name, double pay) {  
33.         this.id = id;  
34.         this.name = name;  
35.         this.pay = pay;  
36.     }  
37.   
38.     public abstract void work();  
39. }  

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

[java] view plain copy

1. package EmployeeDemo;  
2.   
3. public class Manager extends Employee {  
4.   
5.     private double bonus;  
6.     public Manager(int id, String name, double pay,double bouns) {  
7.         super(id, name, pay);  
8.         this.bonus = bouns;  
9.   
10.     }  
11.     public double getBonus() {  
12.         return bonus;  
13.     }  
14.     public void setBonus(double bonus) {  
15.         this.bonus = bonus;  
16.     }  
17.     @Override  
18.     public void work() {  
19.         System.out.println(this.getName()+"'s work is Manage...");  
20.     }  
21.   
22. }  

[java] view plain copy

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

[java] view plain copy

1.  <p>package EmployeeDemo;</p><p>public class Programmer extends Employee {</p><p> public Programmer(int id, String name, double pay) {  
2.   super(id, name, pay);  
3.  }</p><p> @Override  
4.  public void work() {  
5.   System.out.println(this.getName()+"'s work is codeing...");  
6.  }</p><p>}</p>  

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

[java] view plain copy

1. package EmployeeDemo;  
2.   
3. public class EmployeeDemo {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         Programmer p = new Programmer(01, "小明", 8000);  
10.         Manager m = new Manager(02, "小咪", 7000,200);  
11.         p.work();  
12.         m.work();  
13.     }  
14. }  

 

 

 

接口 interface   implements（实现）

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

 

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

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

全局常量：public static final   

抽象方法：public abstract

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

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

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

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

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

 

多态

[java] view plain copy

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

a   instancsof A

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

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

1， 成员变量

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

2， 成员方法

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

3， 静态方法

a)        编译运行都看左边

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

内部类

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

相当于一种封装

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

l        访问特点

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

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

u      需要创建内部类的对象

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

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

 修饰符：

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

[java] view plain copy

1. package InnerClassDemo;  
2.   
3. /** 
4.  *  
5.  * 运行后生成三个class文件 
6.  *  
7.  * Outer.class Outer$Inner.class InnerClassDemo.class 
8.  *  
9.  *  
10.  */  
11.   
12. class Body {  
13.     private String breatheOrgan = "嘴";  
14.   
15.     class Lung// 肺  
16.     {  
17.         void breathe() {  
18.             System.out.println("breathe  with ..." + breatheOrgan);// 内部类可以直接访问外部类的成员  
19.         }  
20.     }  
21.   
22.     public void breatheSys() {// 外部类需要访问内部类时必须建立连接  
23.         Lung l = new Lung();  
24.         l.breathe();  
25.     }  
26. }  
27.   
28. public class InnerClassDemo {  
29.   
30.     public static void main(String[] args) {  
31.   
32.         // Body b = new Body();  
33.         // b.breatheSys();  
34.         // 在外部直接访问内部类  
35.         Body.Lung l = (new Body()).new Lung();  
36.         l.breathe();  
37.     }  
38. }