java基础学习_面向对象(下)02_day09总结

  1. 云栖社区>
  2. 博客>
  3. 正文

java基础学习_面向对象(下)02_day09总结

黑泽明军 发布时间:2018-02-16 23:48:00 浏览297 评论0

摘要: ======================================================================================================================================================...

=============================================================================
=============================================================================
涉及的知识点有:
  1:final关键字(掌握)
  2:多态(掌握)
  3:抽象类(掌握)
  4:接口(掌握)
=============================================================================
=============================================================================
1:final关键字(掌握)
  (0)由于继承中方法有一个现象:方法重写。
    所以,父类的功能,就会被子类给覆盖掉。
    有些时候,我们不想让子类去覆盖掉父类的功能,只能调用但不能去覆盖修改。
    这个时候,针对这种情况,Java就提供了一个关键字:final。
---------------------------------------
  (1)final是最终的意思,常见的final可以修饰类、方法、变量。
  (2)fianl的特点:
    A:final修饰的类,不能被继承。
      编译报错:无法从最终Fu进行继承
      应用:最底层的那个类可以用final修饰,这样该类就不能有儿子了。(即绝育)
    B:final修饰的方法,不能被重写(覆盖/复写)。
      编译报错:Zi中的show()无法覆盖Fu中的show()
    C:final修饰的变量,是一个常量,只能被赋值一次。
      编译报错:无法为最终变量num2分配值

       注意:被final修饰的成员变量没有默认值,必须在构造器(constructor )结束之前被赋予一个明确的值。即在定义被final修饰的成员变量时就给值。 
    小补充:
      常量分为两种:
        1.字面值常量
          例如:"hello"、10、true
        2.自定义常量
          例如:final int x = 10;
---------------------------------------
  (3)final关键字面试题相关:
    public、private等权限修饰符会用来修饰成员变量、构造方法和成员方法。
    不会用来修饰局部变量(在方法内部的变量),因为权限修饰符修饰局部变量是没有意义的,在方法内部的局部变量是被封装好的,外界的方法看不到。
    final既可以修饰局部变量也可以修饰成员变量和成员方法。
    A:final修饰局部变量
      a:当局部变量为基本数据类型    值不能发生改变
        final x = 100;
      b:当局部变量为引用数据类型       地址值不能发生改变,但是该对象的堆内存的内容是可以改变的。
        final Student s = new Student();
        s = new Student();   //对象s重新指向了新的地址值,但是对象s被final修饰了,所以这句会报错!
---------------------------------------
    B:final修的饰变量的初始化时机
      a:被final修饰的变量只能被初始化一次(默认初始化不算哦)。
      b:被final修饰的变量的初始化时机:在对象构造方法执行完毕前进行赋值就行。
        注意:这个时机仅仅针对的是非静态的常量。因为静态的早早就加载了。
      c:变量常见的给值时机
        1.在定义的时候就给值。(推荐方式)
        2.在构造代码块中给值。
        3.在构造方法中给值。
-----------------------------------------------------------------------------
2:多态(掌握)
  (1)某一个事物,在不同时刻表现出来的不同状态。
    猫可以是猫的类型。
      猫 m = new 猫();
    同时猫也是动物的一种,也可以把猫称为动物。
      动物 d = new 猫();
    再举一个例子:水在不同时刻的状态。
---------------------------------------
  (2)多态的前提和体现:
    A:多态有继承或者实现关系。
    B:多态有方法重写。(因为多态是靠方法重写来体现不同状态的)
      其实没有方法重写也是可以的,但是如果没有方法重写就没有意义了。
    C:多态有父类或者父接口引用指向子类对象。
      即:父 f = new 子();

    多态的分类:
      a:具体类的多态
        class Fu {}
        class Zi extends Fu {}

        Fu f = new Zi();
      b:抽象类的多态
        abstract class Fu {}
        class Zi extends Fu {}

        Fu f = new Zi();
      c:接口的多态
        interface Fu {}
        class Zi implements Fu {}

        Fu f = new Zi();
---------------------------------------
  (3)多态中的成员访问特点:
    A:对于多态中的成员变量的访问
      编译看左边,运行看左边。
      因为子可以访问父的成员变量,父不可以访问子的成员变量。(即:对于成员变量,可以向上访问,不可以向下访问。)
    B:对于多态中的构造方法的访问
      创建子类对象的时候,子类的构造都会默认访问父类构造,为了对父类的数据进行初始化。
    C:对于多态中的成员方法的访问
      编译看左边,运行看右边。
      因为成员方法有重写,父类的成员方法会被子类覆盖掉。因为成员方法是跟对象相关的。
    D:对于多态中的静态方法的访问
      编译看左边,运行看左边。
      因为静态方法只能被静态方法重写,但是静态方法根本算不上重写。因为静态是跟类相关的。所以访问静态方法的时候是左边。

    为什么?
      因为成员方法有方法重写,父类的动作被子类重写掉了,所以该动作走的是儿子的。
      也即对于多态中的成员方法的访问看右边(子类)。
---------------------------------------
  (4)多态的好处:
    A:提高了代码的维护性(继承体现)
      因为多态有继承或者实现关系。
    B:提高了代码的扩展性(多态体现)
      原因如下:
      猫狗案例:
        注意几点:
          测试类里面不能放其他东西,只能放创建的对象和通过对象调用的方法。
          把构造方法私有,别人就不能创建对象了,只能通过类名来调用静态方法了。
          针对动物操作的工具类中,调用动物的功能时,形参用动物类进行接收(即多态)。
            即     Animal a = new Cat();
              a = new Dog();
              a = new Pig();
              ......
---------------------------------------
  (5)多态的弊端:
    Fu f = new Zi();
    父类不能使用子类的特有功能(即成员方法)。
      因为我们拿父类去访问子类,但是对于成员方法,父类只能访问在父类中定义的方法,在父类中没有定义的方法不能访问。
      简言之:子可以当做父使用,父不能当做子使用。因为子比父的东西要多。

    我父类就想使用子类的特有功能?行不行?
      答:行。
    那怎么行呢?
      法一:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,重新创建对象,太占内存了。)
        Zi z = new Zi();
      法二:把父类的引用强制赋值给子类的引用。(向下转型)(这样做内存中只有一个对象,省内存!)
        因为引用类型赋值要求类型要兼容!
        Zi z = (Zi)f;
---------------------------------------
  (6)多态中的转型问题:
    A:向上转型
      从子到父
      Fu f = new Zi();
    B:向下转型
      从父到子
      Zi z = (Zi)f;   //前提:要求该f必须是能够转换为Zi的。
---------------------------------------
  (7)孔子装爹的案例帮助大家理解多态
    //然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹。
    //其实就是向上转型。
    孔子爹 k爹 = new 孔子();

    //脱下爹的装备,换上自己的装备。
    //其实就是向下转型。
    孔子 k = (孔子)k爹;
---------------------------------------
  (8)多态的练习
    A:猫狗案例
    B:老师和学生案例
-----------------------------------------------------------------------------
3:抽象类(掌握)
  (1)抽象类的概述:
    把多个共性的东西提取到一个类中,这是继承的做法。
    但是呢,这多个共性的东西,在有些时候,方法声明是一样的,但是方法体不一样。
    也就是说,方法声明是一样,但是每个具体的对象在具体实现的时候内容不一样。
    所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体。
    在Java中,一个没有具体的方法体的方法应该定义为抽象方法。
    而在一个类中如果有抽象方法,该类必须定义为抽象类。
---------------------------------------
  (2)抽象类的特点:
    A:抽象类和抽象方法必须用关键字abstract修饰。
      格式:
        abstract class 类名 {}
        public abstract void eat();    //没有方法体。
        //public abstract void eat() {}  //有方法体,但方法体为空。会报错。
    B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类。
    C:抽象类不能实例化。
      例如:
        abstract class Animal {}
        Animal a = new Animal();   //会报错,因为动物类是抽象的,不能new。
      抽象类有构造方法,但是不能实例化。
      那么抽象类的构造方法的作用是什么呢?
        答:用于子类访问父类数据初始化。
    D:抽象类的子类可能是:
      a:抽象类的子类可以是一个抽象类。这个子类不用重写抽象类中的抽象方法。
      b:抽象类的子类可以是一个具体类(可以new对象,使用多态实例化抽象类)。但这个子类必须重写抽象类中的所有抽象方法。
    E:抽象类的实例化
      通过具体的子类实现的(即:多态的方式。也即:向上转型的方式),其实这也是多态的一种,叫做抽象类多态。
      多态最主要的应用是在抽象类中使用,而不是在具体类中。这样抽象类对外界提供的是抽象的方法,而靠真正具体的子类来重写实现的。
---------------------------------------
  (3)抽象类的成员特点:
    A:抽象类的成员变量的特点
      可以有变量
      也可以有常量
    B:抽象类的构造方法的特点
      有构造方法,但是不能实例化。用于子类访问父类数据的初始化。
    C:抽象类的成员方法的特点
      可以有抽象方法       强制具体的子类必须完成某些动作。
      也可以有非抽象方法     使子类继承非抽象方法,提高代码复用性。
---------------------------------------
  (4)抽象类的练习:
    A:猫狗案例练习
      示例代码如下:

  1 /*
  2     猫狗案例练习:
  3         具体事物:猫,狗
  4         共性:姓名,年龄,吃饭
  5 ---------------------------------------
  6     分析:从具体到抽象
  7         猫类:
  8             成员变量:姓名,年龄
  9             构造方法:无参,带参
 10             成员方法:吃饭(猫吃鱼)
 11             
 12         狗类:
 13             成员变量:姓名,年龄
 14             构造方法:无参,带参
 15             成员方法:吃饭(狗吃肉)
 16             
 17         因为有共性的内容,所以就提取了一个父类。动物类。
 18         但是又由于吃饭的内容不一样,所以吃饭的方法是抽象的,
 19         而方法是抽象的,则类就必须定义为抽象类。得到抽象动物类。
 20         
 21         抽象动物类:
 22             成员变量:姓名,年龄
 23             构造方法:无参,带参
 24             成员方法:吃饭();
 25 ---------------------------------------    
 26     实现:从抽象到具体
 27         抽象动物类:
 28             成员变量:姓名,年龄
 29             构造方法:无参,带参
 30             成员方法:吃饭();
 31             
 32         具体的狗类:
 33             继承自抽象动物类
 34             重写吃饭();
 35             
 36         具体的猫类:
 37             继承自抽象动物类
 38             重写吃饭();
 39             
 40         测试类:
 41 */
 42 
 43 //定义抽象的动物类
 44 abstract class Animal {
 45     //姓名
 46     private String name;
 47     //年龄
 48     private int age;
 49     
 50     public Animal() {}
 51     
 52     public Animal(String name, int age) {
 53         this.name = name;
 54         this.age = age;
 55     }
 56     
 57     public String getName() {
 58         return name;
 59     }
 60     
 61     public void setName(String name) {
 62         this.name = name;
 63     }
 64     
 65     public int getAge() {
 66         return age;
 67     }
 68     
 69     public void setAge(int age) {
 70         this.age = age;
 71     }
 72     
 73     //定义一个抽象的方法
 74     public abstract void eat();
 75 }
 76 
 77 //定义具体的狗类
 78 class Dog extends Animal {
 79     public Dog() {}
 80     
 81     public Dog(String name, int age) {
 82         super(name, age);
 83     }
 84     
 85     public void eat() {
 86         System.out.println("狗吃肉");
 87     }
 88 }
 89 
 90 //定义具体的猫类
 91 class Cat extends Animal {
 92     public Cat() {}
 93     
 94     public Cat(String name, int age) {
 95         super(name, age);
 96     }
 97     
 98     public void eat() {
 99         System.out.println("猫吃鱼");
100     }
101 }
102 
103 //测试类
104 class AbstractTest {
105     public static void main(String[] args) {
106         //测试狗类
107         //具体类测试
108         //方式1:
109         Dog d = new Dog();
110         d.setName("旺财");
111         d.setAge(3);
112         System.out.println(d.getName()+"---"+d.getAge());
113         d.eat();
114         //方式2:
115         Dog d2 = new Dog("旺财", 3);
116         System.out.println(d2.getName()+"---"+d2.getAge());
117         d2.eat();
118         System.out.println("---------------------------");
119         
120         //多态测试:因为子类中没有定义特有功能,所以可以多态实现。
121         Animal a = new Dog();
122         a.setName("旺财");
123         a.setAge(3);
124         System.out.println(a.getName()+"---"+a.getAge());
125         a.eat();
126         
127         Animal a2 = new Dog("旺财", 3);
128         System.out.println(a2.getName()+"---"+a2.getAge());
129         a2.eat();
130         System.out.println("---------------------------");
131         
132         //练习:测试猫类
133         //具体类测试
134         //方式一:
135         Cat c = new Cat();
136         c.setName("多啦A梦");
137         c.setAge(5);
138         System.out.println(c.getName()+"---"+c.getAge());
139         c.eat();
140         //方式二:
141         Cat c2 = new Cat("哆啦A梦", 5);
142         System.out.println(c2.getName()+"---"+c2.getAge());
143         c2.eat();
144         System.out.println("---------------------------");
145         
146         //多态测试:因为子类中没有定义特有功能,所以可以多态实现。
147         Animal a3 = new Cat();
148         a3.setName("哆啦A梦");
149         a3.setAge(5);
150         System.out.println(a3.getName()+"---"+a3.getAge());
151         a3.eat();
152         
153         Animal a4 = new Cat("哆啦A梦", 5);
154         System.out.println(a4.getName()+"---"+a4.getAge());
155         a4.eat();
156         
157     }
158 }

    B:老师案例练习
      示例代码如下:

  1 /*
  2     老师案例练习:
  3         具体事物:基础班老师,就业班老师
  4         共性:姓名,年龄,讲课
  5 ---------------------------------------
  6     分析:    
  7         基础班老师类
  8             姓名,年龄
  9             无参,带参
 10             讲课(讲解JavaSE)
 11         就业班老师类
 12             姓名,年龄
 13             无参,带参
 14             讲课(讲解JavaEE)
 15         抽象老师类
 16             姓名,年龄
 17             无参,带参
 18             讲课();
 19 ---------------------------------------
 20     实现:
 21         抽象老师类
 22         具体的基础班老师类
 23         具体的就业班老师类
 24         测试类
 25 */
 26 
 27 //定义抽象的老师类
 28 abstract class Teacher {
 29     //姓名
 30     private String name;
 31     //年龄
 32     private int age;
 33     
 34     public Teacher() {}
 35     
 36     public Teacher(String name, int age) {
 37         this.name = name;
 38         this.age = age;
 39     }
 40     
 41     public String getName() {
 42         return name;
 43     }
 44     
 45     public void setName(String name) {
 46         this.name = name;
 47     }
 48     
 49     public int getAge() {
 50         return age;
 51     }
 52     
 53     public void setAge(int age) {
 54         this.age = age;
 55     }
 56     
 57     //抽象方法
 58     public abstract void teach();
 59 }
 60 
 61 //具体的基础班老师类
 62 class BasicTeacher extends Teacher {
 63     public BasicTeacher(){}
 64     
 65     public BasicTeacher(String name, int age) {
 66         super(name, age);
 67     }
 68     
 69     public void teach() {
 70         System.out.println("基础班老师讲解JavaSE");
 71     }
 72 }
 73 
 74 //具体的就业班老师类
 75 class WorkTeacher extends Teacher {
 76     public WorkTeacher(){}
 77     
 78     public WorkTeacher(String name, int age) {
 79         super(name, age);
 80     }
 81     
 82     public void teach() {
 83         System.out.println("就业班老师讲解JavaEE");
 84     }
 85 }
 86 
 87 class AbstractTest2 {
 88     public static void main(String[] args) {
 89         //具体的类测试,自己玩
 90         //基础班老师
 91         //方式一:
 92         BasicTeacher bt = new BasicTeacher();
 93         bt.setName("刘意");
 94         bt.setAge(30);
 95         System.out.println(bt.getName()+"---"+bt.getAge());
 96         bt.teach();
 97         //方式二:
 98         bt = new BasicTeacher("刘意", 30);
 99         System.out.println(bt.getName()+"---"+bt.getAge());
100         bt.teach();
101         System.out.println("--------------");
102         
103         //就业班老师
104         //方式一:
105         WorkTeacher wt = new WorkTeacher();
106         wt.setName("林青霞");
107         wt.setAge(27);
108         System.out.println(wt.getName()+"---"+wt.getAge());
109         wt.teach();
110         //方式二:
111         wt = new WorkTeacher("林青霞", 27);
112         System.out.println(wt.getName()+"---"+wt.getAge());
113         wt.teach();
114         System.out.println("---------------");
115         
116         //多态测试:因为子类中没有定义特有功能,所以可以多态实现。
117         //基础班老师
118         Teacher t = new BasicTeacher();
119         System.out.println(t);//BasicTeacher@6d06d69c
120         t.setName("刘意");
121         t.setAge(30);
122         System.out.println(t.getName()+"---"+t.getAge());
123         t.teach();
124         System.out.println("--------------");
125         
126         //对象名没有改哦,因为这是同一个对象此时指向了别的地址。
127         t = new BasicTeacher("刘意", 30);
128         System.out.println(t);//BasicTeacher@7852e922
129         System.out.println(t.getName()+"---"+t.getAge());
130         t.teach();
131         System.out.println("--------------");
132         
133         //就业班老师
134         //对象名依旧没有改哦,因为这是同一个对象此时指向了别的地址。
135         t = new WorkTeacher();
136         System.out.println(t);//WorkTeacher@4e25154f
137         t.setName("林青霞");
138         t.setAge(27);
139         System.out.println(t.getName()+"---"+t.getAge());
140         t.teach();
141         System.out.println("--------------");
142         
143         //对象名依旧依旧没有改哦,因为这是同一个对象此时指向了别的地址。
144         t = new WorkTeacher("林青霞", 27);
145         System.out.println(t);//WorkTeacher@70dea4e
146         System.out.println(t.getName()+"---"+t.getAge());
147         t.teach();
148     }
149 }

    C:学生案例练习
      示例代码如下:类同B,不在赘述。
    D:员工案例练习
      示例代码如下:

  1 /*
  2     假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。
  3     经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。
  4     请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
  5 ---------------------------------------    
  6     分析:
  7         普通员工类
  8             成员变量:姓名、工号以及工资。
  9             成员方法:工作
 10         经理类:
 11             成员变量:姓名、工号以及工资,奖金属性。
 12             成员方法:工作
 13 ---------------------------------------            
 14     实现:
 15         抽象员工类
 16         具体的普通员工类
 17         具体的经理类
 18         测试类
 19 */
 20 
 21 //定义抽象员工类
 22 abstract class Employee {
 23     //姓名、工号以及工资
 24     private String name;
 25     private String id;
 26     private int salary;
 27     
 28     public Employee() {}
 29     
 30     public Employee(String name, String id, int salary) {
 31         this.name = name;
 32         this.id = id;
 33         this.salary = salary;
 34     }
 35     
 36     public String getName() {
 37         return name;
 38     }
 39     
 40     public void setName(String name) {
 41         this.name = name;
 42     }
 43     
 44     public String getId() {
 45         return id;
 46     }
 47     
 48     public void setId(String id) {
 49         this.id = id;
 50     }
 51     
 52     public int getSalary() {
 53         return salary;
 54     }
 55     
 56     public void setSalary(int salary) {
 57         this.salary = salary;
 58     }
 59     
 60     //工作
 61     public abstract void work();
 62 }
 63 
 64 //具体的普通员工类
 65 class Programmer extends Employee {
 66     public Programmer() {}
 67     
 68     public Programmer(String name, String id, int salary) {
 69         super(name, id, salary);
 70     }
 71     
 72     public void work() {
 73         System.out.println("按照需求写代码");
 74     }
 75 }
 76 
 77 //具体的经理类
 78 class Manager extends Employee {
 79     //奖金
 80     private int money; //bonus 奖金
 81 
 82     public Manager() {}
 83     
 84     public Manager(String name, String id, int salary, int money) {
 85         super(name, id, salary);
 86         this.money = money;
 87     }
 88     
 89     public void work() {
 90         System.out.println("跟客户谈需求");
 91     }
 92     
 93     public int getMoney() {
 94         return money;
 95     }
 96     
 97     public void setMoney(int money) {
 98         this.money = money;
 99     }
100 }
101 
102 //测试类
103 class AbstractTest4 {
104     public static void main(String[] args) {
105         //测试具体的普通员工类
106         Employee emp = new Programmer();
107         emp.setName("林青霞");
108         emp.setId("czbk001");
109         emp.setSalary(18000);
110         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
111         emp.work();
112         System.out.println("-------------");
113         emp = new Programmer("林青霞", "czbk001", 18000);
114         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
115         emp.work();
116         System.out.println("-------------");
117         
118         //测试具体的经理类
119         /*
120         emp = new Manager();
121         emp.setName("刘意");
122         emp.setId("czbk002");
123         emp.setSalary(8000);
124         emp.setMoney(2000);
125         */
126         //由于子类经理类有特有的内容-成员变量-奖金,用多态(父类)测试不合适,所以我们用具体的子类来测试。
127         Manager m = new Manager();
128         m.setName("刘意");
129         m.setId("czbk002");
130         m.setSalary(8000);
131         m.setMoney(2000);
132         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
133         m.work();
134         System.out.println("-------------");
135         
136         //通过含参构造方法赋值
137         m = new Manager("刘意", "czbk002", 8000, 2000);
138         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
139         m.work();
140     }
141 }

---------------------------------------
  (5)抽象类的几个小问题
    A:抽象类有构造方法,但是抽象类不能实例化,那么构造方法有什么用?
      答:用于子类访问父类数据的初始化。
    B:一个类如果没有抽象方法,却定义为抽象类,有什么用?
      答:为了不让外界创建该抽象类的对象,要想访问它只能通过该抽象类的子类。
    C:abstract不能和哪些关键字共存?
      a:final         冲突         因为最终方法不能被重写,而抽象的方法需要被具体的子类重写。
        final abstract void show();        //错误: 非法的修饰符组合: abstract和private
      b:private   冲突        因为私有方法不能被继承,所以就不能被重写,而抽象的方法需要被具体的子类重写。
        private abstract void show();   //错误: 非法的修饰符组合: abstract和final
      c:static     无意义    因为抽象方法是没有方法体的,而静态是可以直接通过类名访问的。访问一个没有方法体的方法,意义何在呢?
        static abstract void show();     //错误: 非法的修饰符组合: abstract和static
-----------------------------------------------------------------------------
4:接口(掌握)
  (1)回顾猫狗案例,它们仅仅提供一些基本功能。
    部分的猫会钻火圈,狗会跳高等功能,不是动物本身就具备的,
    是在后面的培养中训练出来的,所以,为了体现事物功能的扩展性,
    Java中就提供了接口来定义这些额外功能,并不给出具体实现(说明是抽象方法),将来哪些猫狗需要被培训,只需要这部分猫狗把这些额外功能实现即可。

    其实接口是最最抽象的抽象类。
---------------------------------------
  (2)接口的特点:
    A:接口用关键字interface修饰
      interface 接口名 {}
    B:类实现接口用implements修饰
      class 类名 implements 接口名 {}
    C:接口不能实例化
      那么,接口如何实例化呢?
      按照多态的方式来实例化。(即就要去做一个具体的子类,通过具体的子类去实例化)
        由此可见,多态有几种方式:
          1.具体类多态(几乎没有,但是讲解是通过具体类讲解的)
          2.抽象类多态(常用)
          3.接口多态(最常用)
    D:接口的实现类(子类)
      接口的实现类格式:接口名+Impl
      a:接口的实现类是一个抽象类。但是意义不大,因为你是抽象类,最终还得需要具体子类。
        //定义动物培训接口
        interface AnimalTrain {
          public abstract void jump();
        }
        //抽象类实现接口
        abstract class Dog implements AnimalTrain {
        }
      b:接口的实现类是一个具体类,这个类必须重写接口中的所有抽象方法。(推荐方案)
        //定义动物培训接口
        interface AnimalTrain {
          public abstract void jump();
        }
        //具体类实现接口
        class Cat implements AnimalTrain {
          public void jump() {
            System.out.println("猫可以跳高了");
          }
        }
---------------------------------------
  (3)接口的成员特点:
    A:接口的成员变量特点:
      只能是常量,并且是静态的。
      因为接口的所有成员变量的默认修饰符都是:public static final
        建议自己手动给出。
    B:接口的构造方法特点:
      接口没有构造方法 。
      那么接口的实现类的无参构造方法默认访问的是谁的无参构造呢?
        答:所有的类都默认继承一个类:Object类。
      因为:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
      又因为:类 Object 只有无参构造方法,所以后来要求所有子类都默认调用的是父类的无参构造方法。

        //接口名+Impl这种格式是接口的实现类格式
        /*
        class InterImpl implements Inter {
          public InterImpl() {
            super();
          }
        }
        */
        //上面的写法等价于下面的写法
        class InterImpl extends Object implements Inter {
          public InterImpl() {
            super();
          }
        }
    C:接口的成员方法特点:
      接口的成员方法只能是抽象的。
      因为接口的所有成员方法的默认修饰符都是:public abstract
        建议自己手动给出。
---------------------------------------
  (4)类与类、类与接口、接口与接口的关系
    A:类与类的关系
      继承关系,只能单继承,不能多继承(只有一个父类),可以多层继承(可以有爷爷)。
        class Son extends Father {}   //正确
        class Son extends Father, Mother {}   //错误
    B:类与接口的关系
      1.实现关系,可以单实现,也可以多实现。(可以多扩展嘛)
      2.还可以在继承一个类的同时,实现多个接口。(继承类 Object 嘛)
        class Son implements Father, Mother {}   //正确
        class Son extends Object implements Father, Mother {}   //正确
    C:接口与接口的关系
      继承关系,可以单继承,也可以多继承。

    小结:Java中的类是单继承的,Java中的接口可以多继承。
---------------------------------------
  (5)抽象类和接口的区别(自己补齐)?
    A:成员区别
      抽象类:
        成员变量:可以有变量,也可以有常量
        构造方法:有(用于子类访问父类数据的初始化)
        成员方法:可以有抽象方法,也可以有非抽象方法
      接口:
        成员变量:只可以是常量
        构造方法:无
        成员方法:只可以是抽象方法
    B:关系区别:
      类与类:
        继承关系,只能单继承和多层继承。
      类与接口:
        实现关系,可以单实现,也可以多实现。
      接口与接口:
        继承关系,可以单继承,也可以多继承。
    C:设计理念不同
      抽象类      被继承体现的是:“is a”的关系,抽象类中定义的是共性功能。
      接口          被实现体现的是:“like a”的关系,接口中定义的是扩展功能。
---------------------------------------
  (6)接口练习:

    A:猫狗案例,加入跳高功能
      共有六个类:(这里将接口理解为最最抽象的类)
        跳高接口
        动物类
        猫类
        狗类
        有跳高功能的猫类
        有跳高功能的狗类
        测试类

示例代码如下:

  1 /*
  2     猫狗案例,加入跳高的额外功能
  3 ---------------------------------------    
  4     分析:从具体到抽象
  5         猫类:
  6             姓名,年龄
  7             吃饭,睡觉
  8         狗类:
  9             姓名,年龄
 10             吃饭,睡觉
 11             
 12         由于有共性功能,所以,我们抽取出一个父类,
 13         抽象动物类:
 14             姓名,年龄
 15             吃饭();
 16             睡觉(){}
 17             
 18         猫类:继承自抽象动物类
 19         狗类:继承自抽象动物类
 20         
 21         跳高的额外功能是一个新的扩展功能,所以我们要定义一个接口。
 22         接口:
 23             跳高
 24             
 25         部分猫类:实现跳高
 26         部分狗类:实现跳高
 27 ---------------------------------------
 28     实现;从抽象到具体
 29      跳高接口
 30      抽象动物类
 31      抽象猫类
 32      抽象狗类
 33      具体的有跳高功能的猫类
 34      具体的有跳高功能的狗类
 35      测试类
 36         
 37     使用:
 38         使用具有跳高功能的具体类进行测试,因为具有跳高功能的具体类具有最多的功能。
 39 */
 40 //定义跳高接口
 41 interface Jumpping {
 42     //跳高功能
 43     public abstract void jump();
 44 }
 45 
 46 //定义抽象动物类
 47 abstract class Animal {
 48     //姓名
 49     private String name;
 50     //年龄
 51     private int age;
 52     
 53     public Animal() {}
 54     
 55     public Animal(String name, int age) {
 56         this.name = name;
 57         this.age = age;
 58     }
 59     
 60     public String getName() {
 61         return name;
 62     }
 63     
 64     public void setName(String name) {
 65         this.name = name;
 66     }
 67     
 68     public int getAge() {
 69         return age;
 70     }
 71     
 72     public void setAge(int age) {
 73         this.age = age;
 74     }
 75     
 76     //吃饭();
 77     public abstract void eat();
 78     
 79     //睡觉(){}
 80     public void sleep() {
 81         System.out.println("睡觉觉了");
 82     }
 83 }
 84 
 85 //具体的猫类
 86 class Cat extends Animal {
 87     public Cat() {}
 88     
 89     public Cat(String name,int age) {
 90         super(name, age);
 91     }
 92     
 93     public void eat() {
 94         System.out.println("猫吃鱼");
 95     }
 96 }
 97 
 98 //具体的狗类
 99 class Dog extends Animal {
100     public Dog() {}
101     
102     public Dog(String name, int age) {
103         super(name, age);
104     }
105     
106     public void eat() {
107         System.out.println("狗吃肉");
108     }
109 }
110 
111 //有跳高功能的具体的猫类
112 class JumpCat extends Cat implements Jumpping {
113     public JumpCat() {}
114     
115     public JumpCat(String name, int age) {
116         super(name,age);
117     }
118 
119     public void jump() {
120         System.out.println("跳高猫");
121     }
122 }
123 
124 //有跳高功能的具体的狗类
125 class JumpDog extends Dog implements Jumpping {
126     public JumpDog() {}
127     
128     public JumpDog(String name, int age) {
129         super(name,age);
130     }
131 
132     public void jump() {
133         System.out.println("跳高狗");
134     }
135 }
136 
137 //测试类
138 class InterfaceTest {
139     public static void main(String[] args) {
140         //定义有跳高功能的具体的猫类并测试
141         //法一:
142         JumpCat jc = new JumpCat();
143         jc.setName("哆啦A梦");
144         jc.setAge(3);
145         System.out.println(jc.getName()+"---"+jc.getAge());
146         jc.eat();
147         jc.sleep();
148         jc.jump();
149         
150         //法二:
151         JumpCat jc2 = new JumpCat("加菲猫", 2);
152         System.out.println(jc2.getName()+"---"+jc2.getAge());
153         jc2.eat();
154         jc2.sleep();
155         jc2.jump();
156         System.out.println("-----------------");
157         
158         //定义有跳高功能的具体的狗类并测试
159         //法一:
160         JumpDog jd = new JumpDog();
161         jd.setName("旺财");
162         jd.setAge(8);
163         System.out.println(jd.getName()+"---"+jd.getAge());
164         jd.eat();
165         jd.sleep();
166         jd.jump();
167         
168         //法二:
169         jd = new JumpDog("旺财", 8);
170         System.out.println(jd.getName()+"---"+jd.getAge());
171         jd.eat();
172         jd.sleep();
173         jd.jump();
174     }
175 }

    B:老师和学生案例,加入抽烟功能
      共有六个类:(这里将接口理解为最最抽象的类)
        抽烟接口
        人类
        学生类
        老师类
        有抽功能的学生类
        有抽功能的老师类
        测试类

示例代码同上,不在赘述!

=============================================================================

我的GitHub地址:https://github.com/heizemingjun
我的博客园地址:http://www.cnblogs.com/chenmingjun
我的蚂蚁笔记博客地址:http://blog.leanote.com/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名,谢谢!】
【云栖快讯】云栖专辑 | 阿里开发者们的第20个感悟:好的工程师为人写代码,而不仅是为编译器  详情请点击

网友评论