Java面向对象(三) 【面向对象深刻：抽象类，接口，内部类等】

时间 2019-11-08

原文原文链接

面向对象(Object Oriented）java

一、抽象类抽象就是将拥有共同方法和属性的对象提取出来。提取后，从新设计一个更加通用、更加大众化的类，就叫抽象类。 1）abstract 关键字修饰类、方法，即抽象类和抽象方法。 2）抽象类能够有具体的方法，或者所有都是具体方法，但一个类中只要有一个抽象方法，那么这个类就是抽象类，而且必须用 abstract 修饰类。 3）抽象类只能用来被继承，则子类必须实现抽象类中的所有抽象方法，不然子类也将是抽象类。抽象类也可主动继承实体类。 4）抽象类不能实例化，即不能用 new 生成实例，因此只能做为父类使用。 5）能够声明一个抽象类型的变量并指向具体子类的对象。 6）抽象类能够实现接口中的方法。 7）抽象类中能够不定义抽象方法，这样作仅仅是不让该类创建对象。编程

 1 //抽象类Animal
 2 abstract class Animal {
 3     abstract public void shout();  //抽象方法
 4 }
 5 class Cat extends Animal { 
 6     //子类必须实现父类的抽象方法，不然编译错误
 7     public void shout() {
 8         System.out.println("喵喵喵！");
 9     }
10     // 定义本身的特有方法
11     public void CatchMouse(){
12         System.out.println("抓老鼠ing....");
13     }
14 }
15 //测试抽象类
16 public class AbstractTest {
17     public static void main(String[] args) {
18     Animal animal = new Cat();// 这样new也是能够的
19         Cat cat = new Cat();
20         cat.shout();
21         cat.seeDoor();
22     }
23 }

AbstractTest Code

疑问解答：一、抽象类中必定有抽象的方法？答：不对的。抽象类中能够有抽象方法，也能够没有抽象方法。二、有抽象方法的类，必定是抽象类？答：对的。若是一个类中包含了至少一个抽象方法，那么该类必须是抽象类。三、抽象类是否能够用final 修饰？答：不能够，final 的类不能当父类，abstract的类只能当父类。互斥的。不能同时使用。四、静态方法是否能够声明成抽象方法？答：不能够，static 和 abstract 也是互斥的。五、抽象方法是否可使用 private 修饰？答：不能够。私有的方法不能子类继承，不能继承就不能重写。抽象方法就是为了让子类实现重写的。互斥的。六、抽象类中定义的抽象方法，每个抽象的方法都是定义了一个规则！！答：每个抽象方法，都是父类给实现的子类定义的一个规则：子类在实现父类抽象方法的时候，无论子类实现的细节如何，可是对实现的功能是有要求的。七、抽象关键字不能够和那些关键字共存？ private => 非法的修饰符组合: abstract和private(抽象须要被覆盖) static => 非法的修饰符组合: abstract和static final => 非法的修饰符组合: abstract和final 八、抽象类和非抽象类的区别？1）抽象类不能被实例化，非抽象类能够实例化。
2）抽象类必须是有子类的，否则没有定义该类的意义。非抽象类不必定了。若是final 修饰就必定没有子类。
3）定义的方式不一样。abstract 修饰抽象类。非抽象类不须要。
4）抽象类中能够有抽象方法。非抽象类不能够有抽象方法的。
二、接口（接口就是规范，定义的是一组规则。接口的出现将“多继承”经过另外一种形式体现出来，即“多实现”）
接口相关规则：
• 接口中全部方法都是抽象的。
• 即便没有显式的将接口中的成员用public标示，也是public访问类型的
• 接口中变量默认用 public static final标示，因此接口中定义的变量就是全局静态常量。
• 能够定义一个新接口，用extends去继承一个已有的接口
• 能够定义一个类，用implements去实现一个接口中全部方法。
• 能够定义一个抽象类，用implements去实现一个接口中部分方法。
如何定义接口?
ide

如何实现接口？
• 子类经过implements来实现接口中的规范
• 接口不能建立实例，可是可用于声明引用变量类型。
• 一个类实现了接口，必须实现接口中全部的方法，而且这些方法只能是public的。
• Java的类只支持单继承，接口支持多继承
接口的多继承：接口彻底支持多继承。和类的继承相似，子接口扩展某个父接口，将会得到父接口中所定义的一切。
测试

examplethis

 1 package com.boom0831;
 2 /**
 3  * 测试接口和实现类
 4  * @author Administrator
 5  *
 6  */
 7 public class InterfaceTest {
 8 
 9     public static void main(String[] args) {
10         Volant v = new Angel();
11         v.fly();
12         
13         Honest h = new GoodMan();
14         h.helpOther();
15     }
16 
17 }
18 /**
19  * 飞行的接口
20  * @author Administrator
21  *
22  */
23 interface Volant{
24     int FLY_HEIGHT = 10000;
25     void fly();
26 }
27 // 善良的接口，天使接口
28 interface Honest{
29     void helpOther();
30 }
31 
32 // 天使实现了飞行和蔼良的接口
33 class Angel implements Volant,Honest{ // 实现类能够实现多个父接口
34     // 实现飞行的接口
35     @Override
36     public void fly() {
37         System.out.println("Angel.fly");
38     }
39     // 实现天使接口
40     @Override
41     public void helpOther() {
42         System.out.println("Angel.helpOther");
43     }
44 }
45 
46 /**
47  * 好人和坏人分别实现不一样的接口
48  * @author Administrator
49  *
50  */
51 class GoodMan implements Honest{
52     @Override
53     public void helpOther() {
54         System.out.println("GoodMan.Honest");
55     }
56 }
57 
58 class Birdman implements Volant{
59     @Override
60     public void fly() {
61         System.out.println("Birdman.Volant");
62     }
63 }

InterfaceTest Code

example
spa

 1 package com.boom0831;
 2 
 3 public class UsbInterface {
 4 
 5     public static void main(String[] args) {
 6         Usb u1 = new Fan();
 7         u1.run();
 8         Usb u2 = new Keyboard();
 9         u2.run();
10         Usb u3 = new Mouse();
11         u3.run();
12     }
13 
14 }
15 interface Usb{
16     void run();
17 }
18 
19 class Fan implements Usb{
20     @Override
21     public void run() {
22         System.out.println("小风扇实现了USB接口。吹啊吹啊 个人骄傲放纵！");
23     }
24 }
25 
26 class Keyboard implements Usb{
27     @Override
28     public void run() {
29         System.out.println("键盘实现了USB接口。开始疯狂的敲代码！funk！");
30     }
31 }
32 
33 class Mouse implements Usb{
34     @Override
35     public void run() {
36         System.out.println("鼠标实现了USB接口。开始了蛇皮风骚走位！");
37     }
38 }

UsbInterface Code

example 升级版设计

 1 package com.boom0831;
 2 /**
 3  * UsbPlug多实现
 4  * @author Administrator
 5  *
 6  */
 7 public class ImplementTest {
 8 
 9     public static void main(String[] args) {
10         Computer computer = new Computer();
11         
12         Mouse mouse = new Mouse();
13         Keyboard keyboard = new Keyboard();
14         computer.load(mouse);
15         computer.load(keyboard);
16         
17         System.out.println("------ 扩展设备:小风扇 、 小台灯 ------");
18         computer.load(new Fun());
19         computer.load(new Light());
20         
21     }
22 
23 }
24 
25 //经过usb 接口 给 设备供电的规则
26 interface UsbPlug{
27     /**
28      * 如何经过usb接口让设备运转起来的规则
29      */
30     void run();
31 }
32 
33 //功能描述的是 插槽如何和usb链接 通电
34 interface UsbSocket{
35     /**
36      * 插槽如何 链接 usb 插头，给插头通电
37      * @param plug  被装备的 usb 插头
38      */
39     void load(UsbPlug plug);
40 }
41 
42 //具备usb 功能的鼠标
43 class Mouse implements UsbPlug{
44     @Override
45     public void run() {
46         System.out.println("鼠标经过UsbPlug接口，鼠标通电成功，蛇皮走位操控电脑！");
47     }
48 }
49 
50 class Keyboard implements UsbPlug{
51     @Override
52     public void run() {
53         System.out.println("键盘经过UsbPlug接口，键盘通电成功，疯狂敲代码到崩溃！");
54         
55     }
56 }
57 
58 class Fun implements UsbPlug{
59     @Override
60     public void run() {
61         System.out.println("小风扇经过UsbPlug接口，小风扇通电成功，吹啊吹啊 个人骄傲放纵！");
62     }
63 }
64 
65 class Light implements UsbPlug{
66     @Override
67     public void run() {
68         System.out.println("小台灯经过UsbPlug接口，小台灯通电成功，发出奥特之光！");
69     }
70 }
71 
72  
73 class Computer implements UsbSocket{
74     // 电脑具备装载UsbPlug接口的功能
75     public void load(UsbPlug plug){
76         plug.run();
77     }
78 }

Implement Code

三、内部类
　　在类内部定义的类为成员内部类，在方法里定义的类为局部内部类，被 static 修饰的为静态内部类。一个类中可有多个内部类。
内部类的做用：
1. 因为内部类提供了更好的封装特性，而且能够很方便的访问外部类的属性。因此，在只为外部类提供服务的状况下能够优先考虑使用内部类。
2. 使用内部类间接实现多继承：每一个内部类都能独立地继承一个类或者实现某些接口，因此不管外部类是否已经继承了某个类或者实现了某些接口，对于内部类没有任何影响。
.成员内部类(可使用private、default、protected、public任意进行修饰。类文件：外部类$内部类.class)

a) 非静态内部类(外部类里使用非静态内部类和平时使用其余类没什么不一样)
i. 非静态内部类必须寄存在一个外部类对象里。若是有一个非静态内部类对象那么必定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
ii. 非静态内部类能够直接访问外部类的成员，可是外部类不能直接访问非静态内部类成员。
iii. 非静态内部类不能有静态方法、静态属性和静态初始化块。
iv. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、建立实例。
v. 成员变量访问要点：
1. 内部类里方法的局部变量：变量名。
2. 内部类属性：this.变量名。
3. 外部类属性：外部类名.this.变量名。
4.建立内部类格式：外部类.内部类变量名 = new 外部类().new 内部类();
3d

 1 package com.boom.innerclass;
 2 
 3 /**
 4  * 测试非静态内部类
 5  * 
 6  * @author Administrator
 7  *
 8  */
 9 public class InnerClass {
10 
11     public static void main(String[] args) {
12         // 建立内部类对象
13         Outer.Inner inner = new Outer().new Inner();
14         inner.show();
15     }
16 
17 }
18 
19 class Outer {
20     private int age = 10;
21 
22     public void testOuter() {
23 
24     }
25 
26     // 非静态内部类Inner
27     class Inner {
28         int age = 30;
29 
30         public void show() {
31             int age = 40;
32             System.out.println("访问外部内成员变量age:" + Outer.this.age);// 10
33             System.out.println("内部类内成员变量age:" + this.age); // 30
34             System.out.println("局部变量age:" + age);//40
35         }
36     }
37 }

View Code

b) 静态内部类内部类前面被static关键字所修饰
1. 当一个静态内部类对象存在，并不必定存在对应的外部类对象。静态内部类的实例方法不能直接访问外部类的实例方法。
2. 静态内部类看作外部类的一个静态成员。外部类的方法中能够经过：“静态内部类.名字”的方式访问静态内部类的静态成员，经过 new 静态内部类()访问静态内部类的实例。

c) 匿名内部类适合那种只须要使用一次的类,通常Android使用的较多。
1. 匿名内部类没有访问修饰符。
2. 匿名内部类没有构造方法。由于它连名字都没有那又何来构造方法.
• 只能实现一个接口，或者继承一个父类
• 适合建立那种只须要一次使用的类，不能重复使用。比较常见的是在图形界面编程GUI里用获得。
• 匿名内部类要使用外部类的局部变量，必须使用final修饰该局部变量
d) 局部内部类:定义在方法内部的，做用域只限于本方法，称为局部内部类。
　　局部内部类的的使用主要是用来解决比较复杂的问题，想建立一个类来辅助咱们的解决方案，到那时又不但愿这个类是公共可用的，因此就产生了局部内部类。局部内部类和成员内部类同样被编译，只是它的做用域发生了改变，它只能在该方法中被使用，出了该方法就会失效。局部内部类在实际开发中应用不多。code