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 }
来源：https://www.cnblogs.com/hoop-superman/p/5495697.html