JavaSE学习总结第10天_面向对象5

时间：2016-05-15 19:27:02 阅读：251 评论：0 收藏：0 [点我收藏+]

标签：

10.01 运动员和教练案例分析

教练和运动员案例:运动员分乒乓球运动员和篮球运动员，教练分乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。

分析:

10.02 运动员和教练案例实现

  1 //定义一个说英语的接口
  2 interface SpeakEnglish 
  3 {
  4     //说英语
  5     public abstract void speak();
  6 }
  7 
  8 //定义人的抽象类
  9 abstract class Person 
 10 {
 11     private String name;
 12     private int age;
 13     
 14     public Person() {}
 15     
 16     public Person(String name,int age) 
 17     {
 18         this.name = name;
 19         this.age = age;
 20     }
 21     
 22     public String getName() 
 23     {
 24         return name;
 25     }
 26     
 27     public void setName(String name) 
 28     {
 29         this.name = name;
 30     }
 31     
 32     public int getAge() 
 33     {
 34         return age;
 35     }
 36     
 37     public void setAge(int age) 
 38     {
 39         this.age = age;
 40     }
 41     
 42     //睡觉
 43     public void sleep() 
 44     {
 45         System.out.println("人都是要睡觉的");
 46     }
 47     
 48     //吃饭
 49     public abstract void eat();
 50 }
 51 
 52 //定义运动员抽象类
 53 abstract class Player extends Person 
 54 {
 55     public Player() {}
 56     
 57     public Player(String name,int age) 
 58     {
 59         super(name,age);
 60     }
 61     
 62     //学习
 63     public abstract void study();
 64 }
 65 
 66 //定义教练抽象类
 67 abstract class Coach extends Person 
 68 {
 69     public Coach() {}
 70     
 71     public Coach(String name,int age) 
 72     {
 73         super(name,age);
 74     }
 75     
 76     //教学
 77     public abstract void teach();
 78 }
 79 
 80 //定义乒乓球运动员具体类
 81 class PingPangPlayer extends Player implements SpeakEnglish 
 82 {
 83     public PingPangPlayer(){}
 84     
 85     public PingPangPlayer(String name,int age) 
 86     {
 87         super(name,age);
 88     }
 89     
 90     //吃
 91     public void eat() 
 92     {
 93         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
 94     }
 95     
 96     //学习
 97     public void study() 
 98     {
 99         System.out.println("乒乓球运动员学习如何发球和接球");
100     }
101     
102     //说英语
103     public void speak() 
104     {
105         System.out.println("乒乓球运动员说英语");
106     }
107 }
108 
109 //定义篮球运动员具体类
110 class BasketballPlayer extends Player 
111 {
112     public BasketballPlayer(){}
113     
114     public BasketballPlayer(String name,int age) 
115     {
116         super(name,age);
117     }
118     
119     //吃
120     public void eat() 
121     {
122         System.out.println("篮球运动员吃牛肉，喝牛奶");
123     }
124     
125     //学习
126     public void study() 
127     {
128         System.out.println("篮球运动员学习如何运球和投篮");
129     }
130 }
131 
132 //定义乒乓球教练具体类
133 class PingPangCoach extends Coach implements SpeakEnglish 
134 {
135     public PingPangCoach(){}
136     
137     public PingPangCoach(String name,int age) 
138     {
139         super(name,age);
140     }
141     
142     //吃
143     public void eat() 
144     {
145         System.out.println("乒乓球教练吃小白菜，喝大米粥");
146     }
147     
148     //教
149     public void teach() 
150     {
151         System.out.println("乒乓球教练教如何发球和接球");
152     }
153     
154     //说英语
155     public void speak() 
156     {
157         System.out.println("乒乓球教练说英语");
158     }
159 }
160 
161 //定义篮球教练具体类
162 class BasketballCoach extends Coach 
163 {
164     public BasketballCoach(){}
165     
166     public BasketballCoach(String name,int age) 
167     {
168         super(name,age);
169     }
170     
171     //吃
172     public void eat() 
173     {
174         System.out.println("篮球教练吃羊肉，喝羊奶");
175     }
176     
177     //教
178     public void teach() 
179     {
180         System.out.println("篮球教练教如何运球和投篮");
181     }
182 }

10.03 运动员和教练案例测试

  1 //定义一个说英语的接口
  2 interface SpeakEnglish 
  3 {
  4     //说英语
  5     public abstract void speak();
  6 }
  7 
  8 //定义人的抽象类
  9 abstract class Person 
 10 {
 11     private String name;
 12     private int age;
 13     
 14     public Person() {}
 15     
 16     public Person(String name,int age) 
 17     {
 18         this.name = name;
 19         this.age = age;
 20     }
 21     
 22     public String getName() 
 23     {
 24         return name;
 25     }
 26     
 27     public void setName(String name) 
 28     {
 29         this.name = name;
 30     }
 31     
 32     public int getAge() 
 33     {
 34         return age;
 35     }
 36     
 37     public void setAge(int age) 
 38     {
 39         this.age = age;
 40     }
 41     
 42     //睡觉
 43     public void sleep() 
 44     {
 45         System.out.println("人都是要睡觉的");
 46     }
 47     
 48     //吃饭
 49     public abstract void eat();
 50 }
 51 
 52 //定义运动员抽象类
 53 abstract class Player extends Person 
 54 {
 55     public Player() {}
 56     
 57     public Player(String name,int age) 
 58     {
 59         super(name,age);
 60     }
 61     
 62     //学习
 63     public abstract void study();
 64 }
 65 
 66 //定义教练抽象类
 67 abstract class Coach extends Person 
 68 {
 69     public Coach() {}
 70     
 71     public Coach(String name,int age) 
 72     {
 73         super(name,age);
 74     }
 75     
 76     //教学
 77     public abstract void teach();
 78 }
 79 
 80 //定义乒乓球运动员具体类
 81 class PingPangPlayer extends Player implements SpeakEnglish 
 82 {
 83     public PingPangPlayer(){}
 84     
 85     public PingPangPlayer(String name,int age) 
 86     {
 87         super(name,age);
 88     }
 89     
 90     //吃
 91     public void eat() 
 92     {
 93         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
 94     }
 95     
 96     //学习
 97     public void study() 
 98     {
 99         System.out.println("乒乓球运动员学习如何发球和接球");
100     }
101     
102     //说英语
103     public void speak() 
104     {
105         System.out.println("乒乓球运动员说英语");
106     }
107 }
108 
109 //定义篮球运动员具体类
110 class BasketballPlayer extends Player 
111 {
112     public BasketballPlayer(){}
113     
114     public BasketballPlayer(String name,int age) 
115     {
116         super(name,age);
117     }
118     
119     //吃
120     public void eat() 
121     {
122         System.out.println("篮球运动员吃牛肉，喝牛奶");
123     }
124     
125     //学习
126     public void study() 
127     {
128         System.out.println("篮球运动员学习如何运球和投篮");
129     }
130 }
131 
132 //定义乒乓球教练具体类
133 class PingPangCoach extends Coach implements SpeakEnglish 
134 {
135     public PingPangCoach(){}
136     
137     public PingPangCoach(String name,int age) 
138     {
139         super(name,age);
140     }
141     
142     //吃
143     public void eat() 
144     {
145         System.out.println("乒乓球教练吃小白菜，喝大米粥");
146     }
147     
148     //教
149     public void teach() 
150     {
151         System.out.println("乒乓球教练教如何发球和接球");
152     }
153     
154     //说英语
155     public void speak() 
156     {
157         System.out.println("乒乓球教练说英语");
158     }
159 }
160 
161 //定义篮球教练具体类
162 class BasketballCoach extends Coach 
163 {
164     public BasketballCoach(){}
165     
166     public BasketballCoach(String name,int age) 
167     {
168         super(name,age);
169     }
170     
171     //吃
172     public void eat() 
173     {
174         System.out.println("篮球教练吃羊肉，喝羊奶");
175     }
176     
177     //教
178     public void teach() 
179     {
180         System.out.println("篮球教练教如何运球和投篮");
181     }
182 }
183 class Demo
184 {
185     public static void main(String[] args)
186     {
187         //测试运动员(乒乓球运动员和篮球运动员)
188         //乒乓球运动员
189         PingPangPlayer ppp = new PingPangPlayer();
190         ppp.setName("王浩");
191         ppp.setAge(33);
192         System.out.println(ppp.getName()+"---"+ppp.getAge());
193         ppp.eat();
194         ppp.sleep();
195         ppp.study();
196         ppp.speak();
197         System.out.println("----------------");
198         
199         //篮球运动员
200         BasketballPlayer bp = new BasketballPlayer();
201         bp.setName("姚明");
202         bp.setAge(34);
203         System.out.println(bp.getName()+"---"+bp.getAge());
204         bp.eat();
205         bp.sleep();
206         bp.study();
207         //bp.speak(); //没有该方法
208     }
209 }

运行结果:

王浩---33
乒乓球运动员吃大白菜，喝小米粥
人都是要睡觉的
乒乓球运动员学习如何发球和接球
乒乓球运动员说英语
----------------
姚明---34
篮球运动员吃牛肉，喝牛奶
人都是要睡觉的
篮球运动员学习如何运球和投篮

10.04 类名作为形式参数

形式参数和返回值问题

形式参数:基本类型、引用类型(类、抽象类、接口)

返回值类型:基本类型、引用类型(类、抽象类、接口)

例:

 1 class Student
 2 {
 3     public void study()
 4     {
 5         System.out.println("好好学习");
 6     }
 7 }
 8 class StudentTest
 9 {
10     //形式参数是一个类
11     public void method(Student s)
12     {
13         s.study();
14     }
15 }
16 class Demo
17 {
18     public static void main(String[] args)
19     {
20         StudentTest st = new StudentTest();
21         Student s = new Student();
22 //需要的是该类的对象
23         st.method(s);
24     }
25 }

运行结果:

好好学习

10.05 抽象类名作为形式参数

例:

 1 abstract class Person
 2 {
 3     public abstract void study();
 4 }
 5 
 6 class Student extends Person
 7 {
 8     public void study()
 9     {
10         System.out.println("好好学习");
11     }
12 }
13 class PersonTest
14 {
15     //形式参数是一个抽象类
16     public void method(Person p)
17     {
18         p.study();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         PersonTest pt = new PersonTest();
26         Person p = new Student();
27         //需要该抽象类的子类对象
28         pt.method(p);
29     }
30 }

运行结果:

好好学习

10.06 接口名作为形式参数

例:

 1 interface Love
 2 {
 3     public abstract void love();
 4 }
 5 class Teacher implements Love
 6 {
 7     public void love()
 8     {
 9         System.out.println("老师爱学生");
10     }
11 }
12 class LoveTest
13 {
14     //形式参数是一个接口
15     public void method(Love l)
16     {
17         l.love();
18     }
19 }
20 class Demo
21 {
22     public static void main(String[] args)
23     {
24         LoveTest lt = new LoveTest();
25         Love l = new Teacher();
26         //需要该接口的实现类对象
27         lt.method(l);
28     }
29 }

运行结果:

老师爱学生

10.07 类名作为返回值类型

例:

 1 class Student
 2 {
 3     public void study()
 4     {
 5         System.out.println("好好学习");
 6     }
 7 }
 8 class StudentTest
 9 {
10     //返回值是一个类
11     public Student getStudent()
12     {
13         //真实返回的是该类的对象
14         return new Student();
15     }
16 }
17 class Demo
18 {
19     public static void main(String[] args)
20     {
21         StudentTest st = new StudentTest();
22         Student s = st.getStudent();
23         s.study();
24     }
25 }

10.08 抽象类名作为返回值类型

例:

 1 abstract class Person
 2 {
 3     public abstract void study();
 4 }
 5 class Student extends Person
 6 {
 7     public void study()
 8     {
 9         System.out.println("好好学习");
10     }
11 }
12 class PersonTest
13 {
14     //返回值是一个抽象类
15     public Person getPerson()
16     {
17         //真实返回的是抽象类的子类对象
18         return new Student();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         PersonTest pt = new PersonTest();
26         Person p = pt.getPerson();
27         p.study();
28     }
29 }

10.09 接口名作为返回值类型

例:

 1 interface Love
 2 {
 3     public abstract void love();
 4 }
 5 class Teacher implements Love
 6 {
 7     public void love()
 8     {
 9         System.out.println("老师爱学生");
10     }
11 }
12 class LoveTest
13 {
14     //返回值是一个接口
15     public Love getLove()
16     {
17         //真实返回的是该接口的实现类对象
18         return new Teacher();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         LoveTest lt = new LoveTest();
26         Love l = lt.getLove();
27         l.love();
28     }
29 }

10.10 链式编程

例:

 1 class Student
 2 {
 3     public void study()
 4     {
 5         System.out.println("好好学习");
 6     }
 7 }
 8 class StudentTest
 9 {
10     public Student getStudent()
11     {
12         return new Student();
13     }
14 }
15 class Demo
16 {
17     public static void main(String[] args)
18     {
19         //链式编程，每次调用方法完毕后返回的是一个对象
20         new StudentTest().getStudent().study();
21     }
22 }

10.11 package关键字的概述及作用

包的概述:其实就是文件夹

作用:对类进行分类管理

包的划分:

例:学生的增加，删除，修改，查询和老师的增加，删除，修改，查询

基本的划分:

按照功能分

cn.itcast.add(AddStudent,AddTeacher)

cn.itcast.delete(DeleteStudent,DeleteTeacher)

cn.itcast.update(UpdateStudent,UpdateTeacher)

cn.itcast.find(FindStudent,FindTeacher)

按照模块分

cn.itcast.teacher(AddTeacher,DeleteTeacher,UpdateTeacher,FindTeacher)

cn.itcast.student(AddStudent,DeleteStudent,UpdateStudent,FindStudent)

10.12 包的定义及注意事项

定义包的格式:package 包名; 多级包用.分开即可

注意事项:

1.package语句必须是程序的第一条可执行的代码

2.package语句在一个java文件中只能有一个

3.如果没有package，默认表示无包名

10.13 带包的类编译和运行

手动式

1:javac编译当前类文件

2:手动建立包对应的文件夹

3:把1步骤的class文件放到2步骤的最终文件夹下

4:通过java命令执行。

注意:需要带包名称执行

例:

1 package cn.itcast;
2 class Demo
3 {
4     public static void main(String[] args)
5     {
6         System.out.println("hello world");
7     }
8 }

运行:

自动式

1:javac编译的时候带上-d即可

例:javac -d . HelloWorld.java (-d后面跟的是目录, .表示当前目录)

2:通过java命令执行。需要带包名称执行。

10.14 不同包下类之间的访问

例:

定义两个类:Demo,Test。

Demo:测试方法(main)

Test:求和方法(sum)

运行步骤如下:

10.15 import关键字的概述和使用

导包概述:不同包下的类之间的访问，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

导包格式:import 包名;

注意:这种方式导入是到类的名称。虽然可以最后写*，但是不建议。使用哪个类就导入哪个类。

例:

面试题:package,import,class有没有顺序关系?

有，package>import>class

package:只能有一个

import:可以有多个

class:可以有多个，建议只写一个

10.16 四种权限修饰符

10.17 类及其组成所使用的常见修饰符

权限修饰符:public、protected、默认的、private

状态修饰符:static、final

抽象修饰符:abstract

1.类:默认，public、final、abstract。其中使用public居多

2.成员变量:四种权限修饰符均可，final、static。其中使用private居多

3.构造方法:四种权限修饰符均可，其他不可以。其中使用public居多

4.成员方法:四种权限修饰符均可，fianl、static、abstract。其中使用public居多

10.18 内部类概述和访问特点

把类定义在其他类的内部，这个类就被称为内部类。

例:在类A中定义了一个类B，类B就是内部类。

内部类的访问特点:

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

外部类要访问内部类的成员，必须创建对象。

例:

 1 class Outer
 2 {
 3     private int num = 10;
 4 //内部类
 5     class Inner
 6     {
 7         public void show()
 8         {
 9             //内部类可以直接访问外部类的成员，包括私有
10             System.out.println("show run..."+num);
11         }
12     }
13     public void method()
14     {
15         //外部类要访问内部类的方法必须创建内部类的对象
16         Inner in = new Inner();
17         in.show();
18     }
19 }

10.19 内部类分类及成员内部类的使用

按照内部类在类中定义的位置不同，可以分为如下两种格式:

在成员位置称为成员内部类

在局部位置称为局部内部类

例:

 1 class Outer
 2 {
 3     //成员内部类
 4     class Inner
 5     {
 6     }
 7     public void method()
 8     {
 9         //局部内部类
10         class Inner
11         {
12         }
13     }
14 }

外界创建成员内部类对象的格式:

外部类名.内部类名对象名 = 外部类对象.内部类对象;

例:

 1 class Outer
 2 {
 3     private int num = 10;
 4     //成员内部类
 5     class Inner
 6     {
 7         public void show()
 8         {
 9             System.out.println(num);
10         }
11     }
12 }
13 class Demo
14 {
15     public static void main(String[] args)
16     {
17         //访问Inner类的show()方法
18 　　　　 //外部类名.内部类名 对象名 = 外部类对象.内部类对象;
19         Outer.Inner oi = new Outer().new Inner();
20         oi.show();
21     }
22 }

10.20 成员内部类的常见修饰符及应用

成员内部类的常见修饰符

1.private 为了保证数据的安全性

例:

 1 class Outer
 2 {
 3     //成员内部类，私有
 4     private class Inner
 5     {
 6         public void show()
 7         {
 8             System.out.println("满足条件输出");
 9         }
10     }
11     public void method(int num)
12     {
13         if(num > 0)
14         {
15             Inner i = new Inner();
16             i.show();
17         }
18     }
19 }
20 class Demo
21 {
22     public static void main(String[] args)
23     {
24         Outer o = new Outer();
25         o.method(-8);
26     }
27 }

上例中，只有当method方法传入的参数大于0时，才可以创建内部类的对象调用方法，否则不创建

2.static 为了让数据访问更方便

被静态修饰的成员内部类只能访问外部类的静态成员
内部类被静态修饰后的方法可以有静态方法也可以有非静态方法

例:

 1 class Outer
 2 {
 3     private static int num = 10;
 4     //成员内部类，静态
 5     public static class Inner
 6     {
 7         //静态方法
 8         public static void show1()
 9         {
10             System.out.println(num);
11         }
12         //非静态方法
13         public void show2()
14         {
15             System.out.println(num);
16         }
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         //成员内部类被静态修饰后的访问方式:
24         //外部类名.内部类名 对象名 = new 外部类名.内部类名();
25         Outer.Inner oi = new Outer.Inner();
26         oi.show1();
27         oi.show2();
28 
29         //静态方法show1()的另一种调用方式
30         Outer.Inner.show1();
31     }
32 }

10.21 成员内部类的面试题

分别输出30、20、10

 1 class Outer
 2 {
 3     public int num = 10;
 4     class Inner
 5     {
 6         public int num = 20;
 7         public void show()
 8         {
 9             int num = 30;
10             System.out.println(num);//30
11             System.out.println(this.num);//20
12             System.out.println(new Outer().num);//10
13             System.out.println(Outer.this.num);//10
14         }
15     }
16 }
17 class Demo
18 {
19     public static void main(String[] args)
20     {
21         Outer.Inner oi = new Outer().new Inner();
22         oi.show();
23     }
24 }

10.22 局部内部类访问局部变量的问题

1.可以直接访问外部类的成员

2.在局部位置可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

例:

 1 class Outer
 2 {
 3     private int num = 10;
 4     public void method()
 5     {
 6         //局部内部类
 7         class Inner
 8         {
 9             public void show()
10             {
11                 //可以直接访问外部类的成员
12                 System.out.println(num);
13             }
14         }
15         //在局部位置创建内部类对象
16         Inner i = new Inner();
17         //通过对象调用内部类方法
18         i.show();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Outer o = new Outer();
26         o.method();
27     }
28 }

局部内部类访问局部变量的注意事项:

例:

 1 class Outer
 2 {
 3     public void method()
 4     {
 5         //局部变量
 6         final int num = 20;
 7         //局部内部类
 8         class Inner
 9         {
10             public void show()
11             {
12                 //局部内部类访问局部变量，该局部变量必须被声明为最终类型
13                 System.out.println(num);
14             }
15         }
16 
17         Inner i = new Inner();
18         i.show();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Outer o = new Outer();
26         o.method();
27     }
28 }

因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

10.23 匿名内部类的格式和理解

匿名内部类就是内部类的简化写法。

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

格式:new 类名或者接口名() {重写方法;}

本质:是一个继承了该类或者实现了该接口的子类匿名对象

例:

10.24 匿名内部类的方法调用

例:

 1 interface Inter
 2 {
 3     public abstract void show1();
 4     public abstract void show2();
 5 }
 6 class Outer
 7 {
 8     public void method()
 9     {
10         /* 一个方法的调用
11         new Inter()
12         {
13             public void show1()
14             {
15                 System.out.println("show1");
16             }
17         }.show1();
18         */
19         //两个方法的调用
20         Inter i = new Inter()
21         {
22             public void show1()
23             {
24                 System.out.println("show1");
25             }
26             public void show2()
27             {
28                 System.out.println("show2");
29             }
30         };
31         i.show1();
32         i.show2();
33     }
34 }
35 class Demo
36 {
37     public static void main(String[] args)
38     {
39         Outer o = new Outer();
40         o.method();
41     }
42 }

10.25 匿名内部类在开发中的应用

例:

 1 interface Person
 2 {
 3     public abstract void study();
 4 }
 5 class PersonDemo
 6 {
 7     public void method(Person p)
 8     {
 9         p.study();
10     }
11 }
12 class Demo
13 {
14     public static void main(String[] args)
15     {
16         PersonDemo pd = new PersonDemo();
17         pd.method(new Person()
18         {
19             public void study()
20             {
21                 System.out.println("好好学习");
22             }
23         });
24     }
25 }

当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递

10.26 匿名内部类的面试题

按照要求，补齐代码，要求在控制台输出”HelloWorld”

 1 interface Inter 
 2 { 
 3     void show(); 
 4 }
 5 class Outer 
 6 { 
 7     //补齐代码 
 8 }
 9 class Demo
10 {
11     public static void main(String[] args)
12     {
13         Outer.method().show();
14     }
15 }

补齐代码:

 1 /*
 2 分析:
 3 1:Outer.method()可以看出method()是Outer中的一个静态方法
 4 2:Outer.method().show()可以看出method()方法的返回值是一个对象。
 5 又由于接口Inter中有一个show()方法,所以method()方法的返回值类型是一个接口。
 6 */
 7 interface Inter 
 8 { 
 9     void show(); 
10 }
11 class Outer 
12 { 
13     //补齐代码 
14     public static Inter method()
15     {
16         return new Inter()
17         {
18             public void show()
19             {
20                 System.out.println("helloworld");
21             }
22         };
23     }
24 }
25 class Demo
26 {
27     public static void main(String[] args)
28     {
29         Outer.method().show();
30     }
31 }

JavaSE学习总结第10天_面向对象5

标签：

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

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行