你的位置:首页 > Java教程

[Java教程]黑马程序员_JavaSE学习总结第09天_面向对象4


------- android培训、java培训、期待与您交流! ---------- 

09.01 final关键字引入

例:

 1 class Fu 2 { 3   public final void show() 4   { 5     System.out.println("访问底层资源"); 6   } 7 } 8 class Zi extends Fu 9 {10   public void show()11   {12     System.out.println("Zi show run");13   }14 }15 class Demo 16 {17   public static void main(String[] args)18   {19     Zi z = new Zi();20     z.show();21   }22 }

上面的代码中父类中的show()方法如果不想被子类覆盖,可以使用final关键字修饰,当子类覆盖了父类中的show()方法,将会报以下错误:

final关键字是最终的意思,可以修饰类,成员变量,成员方法

09.02 final关键字修饰类,方法以及变量的特点

修饰类,类不能被继承

修饰方法,方法不能被重写

修饰变量,变量就变成了常量,只能被赋值一次

09.03 final关键字修饰局部变量

例:

 1 class Student 2 { 3   int age = 10; 4 } 5 class Demo  6 { 7   public static void main(String[] args) 8   { 9     //final修饰基本类型的局部变量10     final int x = 10;11     //x = 20; 值不能被改变12     System.out.println(x);13 14     //final修饰引用类型的局部变量15     final Student s = new Student();16     //s = new Student(); 引用类型的地址值不能变17     s.age = 20;18     System.out.println(s.age);19   }20 }

final修饰基本类型的局部变量,该变量的值不能被改变

final修饰引用类型的局部变量,引用类型的地址值不能变

09.04 final修饰变量的初始化时机

例:

 1 class Test 2 { 3   int num1; 4   final int num2; //在对象构造完毕前即可 5   public Test() 6   { 7     num1 = 100; 8     num2 = 200; 9   }10 }11 class Demo 12 {13   public static void main(String[] args)14   {15     Test t = new Test();16     System.out.println(t.num1);17     System.out.println(t.num2);18   }19 }

09.05 多态的概述和前提条件

多态概述:某一个对象,在不同时刻表现出来的不同状态。

举例:猫可以是猫的类型。Cat c = new Cat();

同时猫也是动物的一种,也可以把猫称为动物。Animal a = new Animal();

多态的前提:

1.有继承关系 

2.有方法重写 

3.有父类引用指向子类对象

09.06 按照多态前提给出代码体现

 1 class Fu 2 { 3   public void show() 4   { 5     System.out.println("Fu show run") 6   } 7 } 8 class Zi extends Fu 9 {10   public void show()11   {12     System.out.println("Zi show run")13   }14 }15 class Demo 16 {17   public static void main(String[] args)18   {19     //父类引用指向子类对象20     Fu f = new Zi();21   }22 }

09.07 多态中的成员访问特点

1.成员变量  编译看左边,运行看左边

例:

 1 class Fu 2 { 3   public int num1 = 10; 4 } 5 class Zi extends Fu 6 { 7   public int num1 = 20; 8   public int num2 = 30; 9   10 }11 class Demo 12 {13   public static void main(String[] args)14   {15     //编译时查看Fu类中是否有num1,有就编译通过16     Fu f = new Zi();17     //运行时输出Fu类中的num118     System.out.println(f.num1);19     //Fu类中没有num2,编译失败20     //System.out.println(f.num2);21   }22 }

2.成员方法  编译看左边,运行看右边

例:

 1 class Fu 2 { 3   public void show() 4   { 5     System.out.println("Fu show run"); 6   } 7  8 } 9 class Zi extends Fu10 {11   public void show()12   {13     System.out.println("Zi show run");14   }15   public void method()16   {17     System.out.println("Zi method run");18   }19 20 }21 class Demo 22 {23   public static void main(String[] args)24   {25     Fu f = new Zi();26     //编译时查看Fu类中是否有show()方法,有就编译通过27     //运行时输出Zi类中show()方法28     f.show();29     //Fu类中没有num2,编译失败30     //f.method();31   }32 }

3.静态方法  编译看左边,运行看左边(静态方法与类相关,不能算方法的重写)

例:

 1 class Fu 2 { 3   public static void show() 4   { 5     System.out.println("Fu show run"); 6   } 7  8 } 9 class Zi extends Fu10 {11   public static void show()12   {13     System.out.println("Zi show run");14   }15   public void method()16   {17     System.out.println("Zi method run");18   }19 20 }21 class Demo 22 {23   public static void main(String[] args)24   {25     Fu f = new Zi();26     //编译时查看Fu类中是否有show()方法,有就编译通过27     //运行时输出Fu类中show()方法28     f.show();29   }30 }

09.08 多态的好处

多态的好处

提高了程序的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

例:

 1 class Animal 2 { 3   public void eat() 4   { 5     System.out.println("eat"); 6   } 7 } 8 class Cat extends Animal 9 {10   public void eat()11   {12     System.out.println("猫吃鱼");13   }14 }15 class Dog extends Animal16 {17   public void eat()18   {19     System.out.println("狗吃肉");20   }21 }22 class Demo 23 {24   public static void main(String[] args)25   {26     Cat c = new Cat();27     Dog d = new Dog();28     method(c);29     method(d);30   }31    //提高了代码的扩展性,前期定义的代码可以使用后期的内容32   public static void method(Animal a)33   {34     a.eat();35   }36 }

09.09 多态的弊端

多态的弊端:不能访问子类特有功能

例:

 1 class Fu 2 { 3   public void show() 4   { 5     System.out.println("Fu show run"); 6   } 7 } 8 class Zi extends Fu 9 {10   public void show()11   {12     System.out.println("Zi show run");13   }14   public void method()15   {16     System.out.println("Zi method run");17   }18 }19 class Demo 20 {21   public static void main(String[] args)22   {23     Fu f = new Zi();24     f.show();25     //错误,不能访问子类特有功能26     //f.method();27   }28 }

09.10 多态中向上转型和向下转型

例:

 1 class Fu 2 { 3   public void show() 4   { 5     System.out.println("Fu show run"); 6   } 7 } 8 class Zi extends Fu 9 {10   public void show()11   {12     System.out.println("Zi show run");13   }14   public void method()15   {16     System.out.println("Zi method run");17   }18 }19 class Demo 20 {21   public static void main(String[] args)22   {23     Fu f = new Zi();24     f.show();25     //使用向下转型以使用子类特有方法26     Zi z = (Zi)f;27     z.method();28   }29 }

运行结果:

Zi show runZi method run

向上转型:从子到父,父类引用指向子类对象。例:Fu f = new Zi();

向下转型:从父到子,父类引用转为子类对象。例:Zi z = (Zi)f;

09.11 孔子装爹案例讲解多态现象

多态的问题理解:

 1 class 孔子爹  2 { 3   public int age = 40; 4    5   public void teach()  6   { 7     System.out.println("讲解JavaSE"); 8   } 9 }10   11 class 孔子 extends 孔子爹12 {13   public int age = 20;14   public void teach()15   {16     System.out.println("讲解论语");17   }18   public void playGame() 19   {20     System.out.println("英雄联盟");21   }22 }23   24   //Java培训特别火,很多人来请孔子爹去讲课,这一天孔子爹被请走了25   //但是还有人来请,就剩孔子在家,价格还挺高。孔子一想,我是不是可以考虑去呢?26   //然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹27   //向上转型28   孔子爹 k爹 = new 孔子();29   //到人家那里去了30   System.out.println(k爹.age); //4031   k爹.teach(); //讲解论语32   //k爹.playGame(); //这是儿子才能做的33   34   //讲完了,下班回家了35   //脱下爹的装备,换上自己的装备36   //向下转型37   孔子 k = (孔子) k爹; 38   System.out.println(k.age); //2039   k.teach(); //讲解论语40   k.playGame(); //英雄联盟

09.12 多态继承中的内存图解

09.13 多态中的对象变化内存图解

09.14 猫狗案例多态版

 1 class Animal 2 { 3   public void eat() 4   { 5     System.out.println("吃饭"); 6   } 7 } 8 class Cat extends Animal 9 {10   public void eat()11   {12     System.out.println("猫吃鱼");13   }14   public void playGame()15   {16     System.out.println("猫玩游戏");17   }18 }19 class Dog extends Animal20 {21   public void eat()22   {23     System.out.println("狗吃肉");24   }25   public void lookDoor()26   {27     System.out.println("狗看门");28   }29 }30 class Demo 31 {32   public static void main(String[] args)33   {34     Animal a = new Dog();35     a.eat();36     Dog d = (Dog)a;37     d.lookDoor();38     System.out.println("------");39     a = new Cat();40     a.eat();41     Cat c = (Cat)a;42     c.playGame();43   }44 }

运行结果:

狗吃肉狗看门------猫吃鱼猫玩游戏

09.15 南北方人案例

 1 class Person  2 { 3   String name; 4   Person(String name) 5   { 6     this.name = name; 7     System.out.println(name); 8   } 9   public void eat() 10   {11     System.out.println("吃饭");12   }13 }14 15 class SouthPerson extends Person 16 {17   SouthPerson(String name)18   {19     super(name);20   }21   public void eat() 22   {23     System.out.println("炒菜,吃米饭");24   }25   26   public void jingShang() 27   {28     System.out.println("经商");29   }30 }31 32 class NorthPerson extends Person 33 {34   NorthPerson(String name)35   {36     super(name);37   }38   public void eat() 39   {40     System.out.println("炖菜,吃馒头");41   }42   43   public void yanJiu() 44   {45     System.out.println("研究");46   }47 }48 class Demo 49 {50   public static void main(String[] args)51   {52     //测试53     //南方人54     Person p = new SouthPerson("南方人");55     p.eat();56     SouthPerson sp = (SouthPerson)p;57     sp.jingShang();58     System.out.println("--------");59     60     //北方人61     p = new NorthPerson("北方人");62     p.eat();63     NorthPerson np = (NorthPerson)p;64     np.yanJiu();65   }66 }

运行结果:

南方人炒菜,吃米饭经商--------北方人炖菜,吃馒头研究

09.16 多态的练习题看程序写结果

1.看程序写结果:先判断有没有问题,如果没有,写出结果

 1 class Fu  2 { 3   public void show()  4   { 5     System.out.println("fu show run"); 6   } 7 } 8  9 class Zi extends Fu 10 {11   public void show() 12   {13     System.out.println("zi show run");14   }15 16   public void method() 17   {18     System.out.println("zi method run");19   }20 }21 class Demo 22 {23   public static void main(String[] args)24   {25     Fu f = new Zi();26     //找不到符号27     //f.method();28     f.show();29   }30 }

运行结果:

zi show run

2.看程序写结果:先判断有没有问题,如果没有,写出结果

 1 class A  2 { 3   public void show()  4   { 5     show2(); 6   } 7   public void show2()  8   { 9     System.out.println("hello ");10   }11 }12 class B extends A 13 {14   /*15   //从父类继承16   public void show() 17   {18     show2();19   }20   */21 22   public void show2() 23   {24     System.out.println("world ");25   }26 }27 class C extends B 28 {29   public void show() 30   {31     super.show();32   }33   public void show2() 34   {35     System.out.println("java ");36   }37 }38 class Demo 39 {40   public static void main(String[] args)41   {42     A a = new B();43     a.show();44     45     B b = new C();46     b.show();47   }48 }

运行结果:

worldjava

09.17 抽象类的引入

动物本身并不是一个具体的事物,而是一个抽象的事物。只有真正的猫,狗才是具体的动物。同理,不同的动物吃的东西应该是不一样的,所以,我们不应该在动物类中给出具体体现,而是应该给出一个声明即可。

在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。

09.18 抽象类的特点

抽象类特点:

1.抽象类和抽象方法必须用abstract关键字修饰

格式: abstract class 类名 {}

public abstract void method();

2.抽象类不一定有抽象方法,有抽象方法的类一定是抽象类

3.抽象类不能实例化,因为抽象类不是具体的,抽象类有构造方法,按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。

4.抽象类的子类如果不重写父类中的抽象方法,那么该子类还是抽象类,否则必须重写抽象类中的所有抽象方法

例:

 1 abstract class Animal 2 { 3   public abstract void eat(); 4 } 5 class Cat extends Animal 6 { 7   public void eat() 8   { 9     System.out.println("猫吃鱼");10   }11 }12 class Demo 13 {14   public static void main(String[] args)15   {16     //多态17     Animal a = new Cat();18     a.eat();19   }20 }

运行结果:

猫吃鱼

09.19 抽象类的成员特点

成员变量:可以是变量,也可以是常量

构造方法:有构造方法,但是不能实例化,构造方法的作用是用于子类访问父类数据的初始化

成员方法:可以有抽象方法限定子类必须完成某些动作,也可以有非抽象方法提高代码复用性

例:

 1 abstract class Animal 2 { 3   public int num1 = 10;//变量 4   public final int num2 = 20;//常量 5   public Animal(){}//构造函数 6   public abstract void show();//抽象方法 7   public void method()//非抽象方法 8   { 9     System.out.println("Animal method run");10   }11 }12 class Cat extends Animal13 {14   public void show()15   {16     System.out.println("Cat show run");17   }18 }19 class Demo 20 {21   public static void main(String[] args)22   {23     //创建对象24     Animal a = new Cat();25     System.out.println(a.num1);//访问变量26     System.out.println(a.num2);//访问常量27     a.show();//访问抽象方法28     a.method();//访问非抽象方法29   }30 }

运行结果:

1020Cat show runAnimal method run

09.20 抽象类练习猫狗案例

 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 abstract class Animal 41 { 42   //姓名 43   private String name; 44   //年龄 45   private int age; 46    47   public Animal() {} 48    49   public Animal(String name,int age)  50   { 51     this.name = name; 52     this.age = age; 53   } 54    55   public String getName()  56   { 57     return name; 58   } 59    60   public void setName(String name)  61   { 62     this.name = name; 63   } 64    65   public int getAge()  66   { 67     return age; 68   } 69    70   public void setAge(int age)  71   { 72     this.age = age; 73   } 74    75   //定义一个抽象方法 76   public abstract void eat(); 77 } 78 //定义具体的狗类 79 class Dog extends Animal  80 { 81   public Dog() {} 82    83   public Dog(String name,int age)  84   { 85     super(name,age); 86   } 87    88   public void eat()  89   { 90     System.out.println("狗吃肉"); 91   } 92 } 93  94 //定义具体的猫类 95 class Cat extends Animal  96 { 97   public Cat() {} 98    99   public Cat(String name,int age) 100   {101     super(name,age);102   }103   104   public void eat() 105   {106     System.out.println("猫吃鱼");107   }108 }109 class Demo 110 {111   public static void main(String[] args)112   {113     //测试狗类,具体类用法 方式1114     Dog d = new Dog();115     d.setName("旺财");116     d.setAge(3);117     System.out.println(d.getName()+"---"+d.getAge());118     d.eat();119     //测试狗类,具体类用法 方式2:120     Dog d2 = new Dog("旺财",3);121     System.out.println(d2.getName()+"---"+d2.getAge());122     d2.eat();123     System.out.println("-------------");124     //测试狗类,多态用法 方式1:125     Animal a = new Dog();126     a.setName("旺财");127     a.setAge(3);128     System.out.println(a.getName()+"---"+a.getAge());129     a.eat();130     //测试狗类,多态用法 方式2:131     Animal a2 = new Dog("旺财",3);132     System.out.println(a2.getName()+"---"+a2.getAge());133     a2.eat();134   }135 }

运行结果:

旺财---3狗吃肉旺财---3狗吃肉-------------旺财---3狗吃肉旺财---3狗吃肉

09.21 抽象类练习老师案例

 1 /* 2 老师案例 3     具体事物:基础班老师,就业班老师 4     共性:姓名,年龄,讲课。 5  6 分析:   7   基础班老师 8     姓名,年龄 9     讲课。 10   就业班老师 11     姓名,年龄 12     讲课。 13 实现: 14   老师类 15     基础班老师 16     就业班老师 17 */ 18 //定义抽象的老师类 19 abstract class Teacher  20 { 21   //姓名 22   private String name; 23   //年龄 24   private int age; 25    26   public Teacher() {} 27    28   public Teacher(String name,int age)  29   { 30     this.name = name; 31     this.age = age; 32   } 33    34   public String getName()  35   { 36     return name; 37   } 38    39   public void setName(String name)  40   { 41     this.name = name; 42   } 43    44   public int getAge()  45   { 46     return age; 47   } 48    49   public void setAge(int age)  50   { 51     this.age = age; 52   } 53    54   //抽象方法 55   public abstract void teach(); 56 } 57  58 //基础班老师类 59 class BasicTeacher extends Teacher  60 { 61   public BasicTeacher(){} 62    63   public BasicTeacher(String name,int age)  64   { 65     super(name,age); 66   } 67    68   public void teach()  69   { 70     System.out.println("基础班老师讲解JavaSE"); 71   } 72 } 73  74 //就业班老师类 75 class WorkTeacher extends Teacher  76 { 77   public WorkTeacher(){} 78    79   public WorkTeacher(String name,int age)  80   { 81     super(name,age); 82   } 83    84   public void teach()  85   { 86     System.out.println("就业班老师讲解JavaEE"); 87   } 88 } 89 class Demo  90 { 91   public static void main(String[] args) 92   { 93     //多态测试 94     //基础班老师 95     Teacher t = new BasicTeacher(); 96     t.setName("小明"); 97     t.setAge(30); 98     System.out.println(t.getName()+"---"+t.getAge()); 99     t.teach();100     System.out.println("--------------------");101     102     t = new BasicTeacher("小明",30);103     System.out.println(t.getName()+"---"+t.getAge());104     t.teach();105     System.out.println("--------------------");106     107     //就业班老师108     t = new WorkTeacher();109     t.setName("小红");110     t.setAge(35);111     System.out.println(t.getName()+"---"+t.getAge());112     t.teach();113     System.out.println("--------------------");114     115     t = new WorkTeacher("小红",35);116     System.out.println(t.getName()+"---"+t.getAge());117     t.teach();118   }119 }

运行结果:

小明---30基础班老师讲解JavaSE--------------------小明---30基础班老师讲解JavaSE--------------------小红---35就业班老师讲解JavaEE--------------------小红---35就业班老师讲解JavaEE

09.22 抽象类练习学员案例

 1 /* 2 学生案例 3     具体事务:基础班学员,就业班学员 4     共性:姓名,年龄,班级,学习,吃饭 5  6 分析: 7   基础班学员 8     成员变量:姓名,年龄,班级 9     成员方法:学习,吃饭 10   就业班学员 11     成员变量:姓名,年龄,班级 12     成员方法:学习,吃饭 13        14 得到一个学员类。 15   成员变量:姓名,年龄,班级 16   成员方法:学习,吃饭 17        18 实现: 19   学员类 20   基础班学员 21   就业班学员 22 */ 23 //定义抽象学员类 24 abstract class Student  25 { 26   //姓名 27   private String name; 28   //年龄 29   private int age; 30   //班级 31   private String grand; 32    33   public Student() {} 34    35   public Student(String name,int age,String grand)  36   { 37     this.name = name; 38     this.age = age; 39     this.grand = grand; 40   } 41    42   public String getName()  43   { 44     return name; 45   } 46    47   public void setName(String name)  48   { 49     this.name = name; 50   } 51    52   public int getAge()  53   { 54     return age; 55   } 56    57   public void setAge(int age)  58   { 59     this.age = age; 60   } 61    62   public String getGrand()  63   { 64     return grand; 65   } 66    67   public void setGrand(String grand)  68   { 69     this.grand = grand; 70   } 71    72   //学习 73   public abstract void study(); 74    75   //吃饭 76   public void eat()  77   { 78     System.out.println("吃饭"); 79   } 80 } 81  82 //具体基础班学员类 83 class BasicStudent extends Student  84 { 85   public BasicStudent() {} 86    87   public BasicStudent(String name,int age,String grand)  88   { 89     super(name,age,grand); 90   } 91   //重写父类抽象方法 92   public void study()  93   { 94     System.out.println("基础班学员学习JavaSE"); 95   } 96 } 97  98 //具体就业班学员类 99 class WorkStudent extends Student 100 {101   public WorkStudent() {}102   103   public WorkStudent(String name,int age,String grand) 104   {105     super(name,age,grand);106   }107   //重写父类抽象方法108   public void study() 109   {110     System.out.println("就业班学员学习JavaEE");111   }112 }113 class Demo 114 {115   public static void main(String[] args)116   {117     //按照多态的方式测试基础班学员118     Student s = new BasicStudent();119     s.setName("小明");120     s.setAge(27);121     s.setGrand("1111");122     System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());123     s.study();124     s.eat();125     System.out.println("--------------");126     127     s = new BasicStudent("小红",28,"1111");128     System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());129     s.study();130     s.eat();131   }132 }

运行结果:

小明---27---1111基础班学员学习JavaSE吃饭--------------小红---28---1111基础班学员学习JavaSE吃饭

09.23 抽象类练习员工案例

假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。

经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。

请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

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

运行结果:

小明---czbk001---18000按照需求写代码-------------小明---czbk001---18000按照需求写代码-------------小红---czbk002---8000---2000跟客户谈需求-------------小红---czbk002---8000---2000跟客户谈需求

09.24 抽象类中的小问题

1.一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?

可以。不让创建对象。

2.abstract不能和哪些关键字共存

private 冲突

final   冲突

static  无意义

09.25 接口的引入

为了体现事物功能的扩展性,Java中就提供了接口来定义这些额外功能,并不给出具体实现,将来哪些猫狗需要被培训,只需要这部分猫狗把这些额外功能实现即可。

09.26 接口的特点

接口特点:接口用关键字interface表示,格式:interface 接口名 {}

类实现接口用implements表示,格式:class 类名 implements 接口名 {}

接口不能实例化,按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。

接口的子类要么是抽象类,要么重写接口中的所有抽象方法

09.27 接口的成员特点

成员变量:只能是常量,默认修饰符 public static final

构造方法:没有,因为接口主要是扩展功能的,而没有具体存在

成员方法:只能是抽象方法,默认修饰符 public abstract

09.28 类与类,类与接口,接口与接口的关系

类与类的关系:继承关系,只能单继承,但是可以多层继承

类与接口的关系:实现关系,可以单实现,也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口的关系:继承关系,可以单继承,也可以多继承

09.29 抽象类和接口的区别

成员区别:

抽象类:成员变量,可以是变量也可以是常量。构造方法,有。成员方法,可以是抽象方法也可以是非抽象方法

接口:成员变量,只可以是常量。构造方法,没有。成员方法,只可以是抽象方法

关系区别:

类与类继承,单继承

类与接口实现,单实现,多实现

接口与接口继承,单继承,多继承

设计理念区别:

抽象类被继承体现的是:”is a”的关系。继承体系的共性功能

接口被实现体现的是:”like a”的关系。继承体系的扩展功能

09.30 猫狗案例加入跳高功能分析

猫狗案例,加入跳高的额外功能

分析:从具体到抽象

猫:姓名,年龄  吃饭,睡觉

狗:姓名,年龄  吃饭,睡觉

由于有共性功能,所以,我们抽取出一个父类:

动物:姓名,年龄     吃饭();睡觉(){}      

猫:继承自动物

狗:继承自动物

跳高的额外功能是一个新的扩展功能,所以我们要定义一个接口:跳高   

部分猫:实现跳高

部分狗:实现跳高

实现:从抽象到具体

使用:使用具体类

09.31 猫狗案例加入跳高功能代码实现

 1 //定义跳高接口 2 interface Jumpping  3 { 4   //跳高功能 5   public abstract void jump(); 6 } 7  8 //定义抽象类 9 abstract class Animal  10 { 11   //姓名 12   private String name; 13   //年龄 14   private int age; 15    16   public Animal() {} 17    18   public Animal(String name,int age)  19   { 20     this.name = name; 21     this.age = age; 22   } 23    24   public String getName()  25   { 26     return name; 27   } 28    29   public void setName(String name)  30   { 31     this.name = name; 32   } 33    34   public int getAge()  35   { 36     return age; 37   } 38    39   public void setAge(int age)  40   { 41     this.age = age; 42   } 43    44   //吃饭(); 45   public abstract void eat(); 46    47   //睡觉(){} 48   public void sleep()  49   { 50     System.out.println("睡觉"); 51   } 52 } 53  54 //具体猫类 55 class Cat extends Animal  56 { 57   public Cat(){} 58    59   public Cat(String name,int age)  60   { 61     super(name,age); 62   } 63    64   public void eat()  65   { 66     System.out.println("猫吃鱼"); 67   } 68 } 69  70 //具体狗类 71 class Dog extends Animal  72 { 73   public Dog(){} 74    75   public Dog(String name,int age)  76   { 77     super(name,age); 78   } 79    80   public void eat()  81   { 82     System.out.println("狗吃肉"); 83   } 84 } 85  86 //有跳高功能的猫 87 class JumpCat extends Cat implements Jumpping  88 { 89   public JumpCat() {} 90    91   public JumpCat(String name,int age)  92   { 93     super(name,age); 94   } 95  96   public void jump()  97   { 98     System.out.println("跳高猫"); 99   }100 }101 102 //有跳高功能的狗103 class JumpDog extends Dog implements Jumpping 104 {105   public JumpDog() {}106   107   public JumpDog(String name,int age) 108   {109     super(name,age);110   }111 112   public void jump() 113   {114     System.out.println("跳高狗");115   }116 }117 class Demo118 {119   public static void main(String[] args)120   {121     //定义猫并测试122     JumpCat jc = new JumpCat();123     jc.setName("哆啦A梦");124     jc.setAge(3);125     System.out.println(jc.getName()+"---"+jc.getAge());126     jc.eat();127     jc.sleep();128     jc.jump();129     System.out.println("-----------------");130     131     JumpCat jc2 = new JumpCat("加菲猫",2);132     System.out.println(jc2.getName()+"---"+jc2.getAge());133     jc2.eat();134     jc2.sleep();135     jc2.jump();136   }137 }

运行结果:

哆啦A梦---3猫吃鱼睡觉跳高猫------------加菲猫---2猫吃鱼睡觉跳高猫

09.32 老师学生案例加入抽烟功能分析及代码实现

 1 /* 2 老师和学生案例,加入抽烟的额外功能 3 分析:从具体到抽象 4 老师:姓名,年龄,吃饭,睡觉 5 学生:姓名,年龄,吃饭,睡觉 6 由于有共性功能,我们提取出一个父类,人类。 7 人类: 8   姓名,年龄 9   吃饭(); 10   睡觉(){} 11 抽烟的额外功能不是人或者老师,或者学生一开始就应该具备的,所以,我们把它定义为接口 12 部分老师抽烟:实现抽烟接口 13 部分学生抽烟:实现抽烟接口 14 实现:从抽象到具体 15 */ 16 //定义抽烟接口 17 interface Smoking  18 { 19   //抽烟的抽象方法 20   public abstract void smoke(); 21 } 22  23 //定义抽象人类 24 abstract class Person  25 { 26   //姓名 27   private String name; 28   //年龄 29   private int age; 30    31   public Person() {} 32    33   public Person(String name,int age) 34   { 35     this.name = name; 36     this.age = age; 37   } 38    39   public String getName()  40   { 41     return name; 42   } 43    44   public void setName(String name)  45   { 46     this.name = name; 47   } 48    49   public int getAge()  50   { 51     return age; 52   } 53    54   public void setAge(int age)  55   { 56     this.age = age; 57   } 58    59   //吃饭(); 60   public abstract void eat(); 61    62   //睡觉(){} 63   public void sleep() 64   { 65     System.out.println("睡觉"); 66   } 67 } 68  69 //具体老师类 70 class Teacher extends Person  71 { 72   public Teacher() {} 73    74   public Teacher(String name,int age)  75   { 76     super(name,age); 77   } 78    79   public void eat()  80   { 81     System.out.println("吃大白菜"); 82   } 83 } 84  85 //具体学生类 86 class Student extends Person  87 { 88   public Student() {} 89    90   public Student(String name,int age)  91   { 92     super(name,age); 93   } 94    95   public void eat()  96   { 97     System.out.println("吃红烧肉"); 98   } 99 }100 101 //抽烟的老师102 class SmokingTeacher extends Teacher implements Smoking 103 {104   public SmokingTeacher() {}105   106   public SmokingTeacher(String name,int age) 107   {108     super(name,age);109   }110 111   public void smoke()112   {113     System.out.println("抽烟的老师");114   }115 }116 117 //抽烟的学生118 class SmokingStudent extends Student implements Smoking 119 {120   public SmokingStudent() {}121   122   public SmokingStudent(String name,int age)123   {124     super(name,age);125   }126 127   public void smoke() 128   {129     System.out.println("抽烟的学生");130   }131 }132 class Demo133 {134   public static void main(String[] args)135   {136     //测试学生137     SmokingStudent ss = new SmokingStudent();138     ss.setName("小明");139     ss.setAge(27);140     System.out.println(ss.getName()+"---"+ss.getAge());141     ss.eat();142     ss.sleep();143     ss.smoke();144     System.out.println("------------");145     146     SmokingStudent ss2 = new SmokingStudent("小强",30);147     System.out.println(ss2.getName()+"---"+ss2.getAge());148     ss2.eat();149     ss2.sleep();150     ss2.smoke();151   }152 }