码迷,mamicode.com
首页 > 编程语言 > 详细

JavaSE学习总结第09天_面向对象4

时间:2016-05-15 19:37:39      阅读:237      评论:0      收藏:0      [点我收藏+]

标签:

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类中的num1
18         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 Fu
10 {
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 Fu
10 {
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 Animal
16 {
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 run
Zi 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); //40
31     k爹.teach(); //讲解论语
32     //k爹.playGame(); //这是儿子才能做的
33     
34     //讲完了,下班回家了
35     //脱下爹的装备,换上自己的装备
36     //向下转型
37     孔子 k = (孔子) k爹; 
38     System.out.println(k.age); //20
39     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 Animal
20 {
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 }
技术分享

运行结果:

world
java

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 Animal
13 {
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 }
技术分享

运行结果:

10
20
Cat show run
Animal 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         //测试狗类,具体类用法 方式1
114         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 Demo
118 {
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 Demo
133 {
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 }

JavaSE学习总结第09天_面向对象4

标签:

原文地址:http://www.cnblogs.com/hoop-superman/p/5495694.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!