------- android培训、java培训、期待与您交流！ ----------
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 Demo184 {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 Demo17 {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 PersonTest14 {15 //形式参数是一个抽象类16 public void method(Person p)17 {18 p.study();19 }20 }21 class Demo22 {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 LoveTest13 {14 //形式参数是一个接口15 public void method(Love l)16 {17 l.love();18 }19 }20 class Demo21 {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 Demo18 {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 PersonTest13 {14 //返回值是一个抽象类15 public Person getPerson()16 {17 //真实返回的是抽象类的子类对象18 return new Student();19 }20 }21 class Demo22 {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 LoveTest13 {14 //返回值是一个接口15 public Love getLove()16 {17 //真实返回的是该接口的实现类对象18 return new Teacher();19 }20 }21 class Demo22 {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 Demo16 {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 Demo3 {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 Inner11 {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 Demo14 {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 Demo21 {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 Demo20 {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);//3011 System.out.println(this.num);//2012 System.out.println(new Outer().num);//1013 System.out.println(Outer.this.num);//1014 }15 }16 }17 class Demo18 {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 Demo22 {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 Demo22 {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 Demo36 {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 Demo13 {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 Demo10 {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 Demo26 {27 public static void main(String[] args)28 {29 Outer.method().show();30 }31 }