10.01 运动员和教练案例分析
教练和运动员案例:运动员分乒乓球运动员和篮球运动员，教练分乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。
分析:
10.02 运动员和教练案例实现
//定义一个说英语的接口
interface SpeakEnglish
{
//说英语
public abstract void speak();
} //定义人的抽象类
abstract class Person
{
private String name;
private int age; public Person() {} public Person(String name,int age)
{
this.name = name;
this.age = age;
} public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} //睡觉
public void sleep()
{
System.out.println("人都是要睡觉的");
} //吃饭
public abstract void eat();
} //定义运动员抽象类
abstract class Player extends Person
{
public Player() {} public Player(String name,int age)
{
super(name,age);
} //学习
public abstract void study();
} //定义教练抽象类
abstract class Coach extends Person
{
public Coach() {} public Coach(String name,int age)
{
super(name,age);
} //教学
public abstract void teach();
} //定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish
{
public PingPangPlayer(){} public PingPangPlayer(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
} //学习
public void study()
{
System.out.println("乒乓球运动员学习如何发球和接球");
} //说英语
public void speak()
{
System.out.println("乒乓球运动员说英语");
}
} //定义篮球运动员具体类
class BasketballPlayer extends Player
{
public BasketballPlayer(){} public BasketballPlayer(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("篮球运动员吃牛肉，喝牛奶");
} //学习
public void study()
{
System.out.println("篮球运动员学习如何运球和投篮");
}
} //定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish
{
public PingPangCoach(){} public PingPangCoach(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("乒乓球教练吃小白菜，喝大米粥");
} //教
public void teach()
{
System.out.println("乒乓球教练教如何发球和接球");
} //说英语
public void speak()
{
System.out.println("乒乓球教练说英语");
}
} //定义篮球教练具体类
class BasketballCoach extends Coach
{
public BasketballCoach(){} public BasketballCoach(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("篮球教练吃羊肉，喝羊奶");
} //教
public void teach()
{
System.out.println("篮球教练教如何运球和投篮");
}
}
10.03 运动员和教练案例测试
//定义一个说英语的接口
interface SpeakEnglish
{
//说英语
public abstract void speak();
} //定义人的抽象类
abstract class Person
{
private String name;
private int age; public Person() {} public Person(String name,int age)
{
this.name = name;
this.age = age;
} public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} //睡觉
public void sleep()
{
System.out.println("人都是要睡觉的");
} //吃饭
public abstract void eat();
} //定义运动员抽象类
abstract class Player extends Person
{
public Player() {} public Player(String name,int age)
{
super(name,age);
} //学习
public abstract void study();
} //定义教练抽象类
abstract class Coach extends Person
{
public Coach() {} public Coach(String name,int age)
{
super(name,age);
} //教学
public abstract void teach();
} //定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish
{
public PingPangPlayer(){} public PingPangPlayer(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
} //学习
public void study()
{
System.out.println("乒乓球运动员学习如何发球和接球");
} //说英语
public void speak()
{
System.out.println("乒乓球运动员说英语");
}
} //定义篮球运动员具体类
class BasketballPlayer extends Player
{
public BasketballPlayer(){} public BasketballPlayer(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("篮球运动员吃牛肉，喝牛奶");
} //学习
public void study()
{
System.out.println("篮球运动员学习如何运球和投篮");
}
} //定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish
{
public PingPangCoach(){} public PingPangCoach(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("乒乓球教练吃小白菜，喝大米粥");
} //教
public void teach()
{
System.out.println("乒乓球教练教如何发球和接球");
} //说英语
public void speak()
{
System.out.println("乒乓球教练说英语");
}
} //定义篮球教练具体类
class BasketballCoach extends Coach
{
public BasketballCoach(){} public BasketballCoach(String name,int age)
{
super(name,age);
} //吃
public void eat()
{
System.out.println("篮球教练吃羊肉，喝羊奶");
} //教
public void teach()
{
System.out.println("篮球教练教如何运球和投篮");
}
}
class Demo
{
public static void main(String[] args)
{
//测试运动员(乒乓球运动员和篮球运动员)
//乒乓球运动员
PingPangPlayer ppp = new PingPangPlayer();
ppp.setName("王浩");
ppp.setAge(33);
System.out.println(ppp.getName()+"---"+ppp.getAge());
ppp.eat();
ppp.sleep();
ppp.study();
ppp.speak();
System.out.println("----------------"); //篮球运动员
BasketballPlayer bp = new BasketballPlayer();
bp.setName("姚明");
bp.setAge(34);
System.out.println(bp.getName()+"---"+bp.getAge());
bp.eat();
bp.sleep();
bp.study();
//bp.speak(); //没有该方法
}
}
运行结果:
王浩---33
乒乓球运动员吃大白菜，喝小米粥
人都是要睡觉的
乒乓球运动员学习如何发球和接球
乒乓球运动员说英语
----------------
姚明---34
篮球运动员吃牛肉，喝牛奶
人都是要睡觉的
篮球运动员学习如何运球和投篮
10.04 类名作为形式参数
形式参数和返回值问题
形式参数:基本类型、引用类型(类、抽象类、接口)
返回值类型:基本类型、引用类型(类、抽象类、接口)
例:
class Student
{
public void study()
{
System.out.println("好好学习");
}
}
class StudentTest
{
//形式参数是一个类
public void method(Student s)
{
s.study();
}
}
class Demo
{
public static void main(String[] args)
{
StudentTest st = new StudentTest();
Student s = new Student();
//需要的是该类的对象
st.method(s);
}
}
运行结果:
好好学习
10.05 抽象类名作为形式参数
例:
abstract class Person
{
public abstract void study();
} class Student extends Person
{
public void study()
{
System.out.println("好好学习");
}
}
class PersonTest
{
//形式参数是一个抽象类
public void method(Person p)
{
p.study();
}
}
class Demo
{
public static void main(String[] args)
{
PersonTest pt = new PersonTest();
Person p = new Student();
//需要该抽象类的子类对象
pt.method(p);
}
}
运行结果:
好好学习
10.06 接口名作为形式参数
例:
interface Love
{
public abstract void love();
}
class Teacher implements Love
{
public void love()
{
System.out.println("老师爱学生");
}
}
class LoveTest
{
//形式参数是一个接口
public void method(Love l)
{
l.love();
}
}
class Demo
{
public static void main(String[] args)
{
LoveTest lt = new LoveTest();
Love l = new Teacher();
//需要该接口的实现类对象
lt.method(l);
}
}
运行结果:
老师爱学生
10.07 类名作为返回值类型
例:
class Student
{
public void study()
{
System.out.println("好好学习");
}
}
class StudentTest
{
//返回值是一个类
public Student getStudent()
{
//真实返回的是该类的对象
return new Student();
}
}
class Demo
{
public static void main(String[] args)
{
StudentTest st = new StudentTest();
Student s = st.getStudent();
s.study();
}
}
10.08 抽象类名作为返回值类型
例:
abstract class Person
{
public abstract void study();
}
class Student extends Person
{
public void study()
{
System.out.println("好好学习");
}
}
class PersonTest
{
//返回值是一个抽象类
public Person getPerson()
{
//真实返回的是抽象类的子类对象
return new Student();
}
}
class Demo
{
public static void main(String[] args)
{
PersonTest pt = new PersonTest();
Person p = pt.getPerson();
p.study();
}
}
10.09 接口名作为返回值类型
例:
interface Love
{
public abstract void love();
}
class Teacher implements Love
{
public void love()
{
System.out.println("老师爱学生");
}
}
class LoveTest
{
//返回值是一个接口
public Love getLove()
{
//真实返回的是该接口的实现类对象
return new Teacher();
}
}
class Demo
{
public static void main(String[] args)
{
LoveTest lt = new LoveTest();
Love l = lt.getLove();
l.love();
}
}
10.10 链式编程
例:
class Student
{
public void study()
{
System.out.println("好好学习");
}
}
class StudentTest
{
public Student getStudent()
{
return new Student();
}
}
class Demo
{
public static void main(String[] args)
{
//链式编程，每次调用方法完毕后返回的是一个对象
new StudentTest().getStudent().study();
}
}
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命令执行。
注意:需要带包名称执行
例:
package cn.itcast;
class Demo
{
public static void main(String[] args)
{
System.out.println("hello world");
}
}
运行:
自动式
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就是内部类。
内部类的访问特点:
内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。
例:
class Outer
{
private int num = 10;
//内部类
class Inner
{
public void show()
{
//内部类可以直接访问外部类的成员，包括私有
System.out.println("show run..."+num);
}
}
public void method()
{
//外部类要访问内部类的方法必须创建内部类的对象
Inner in = new Inner();
in.show();
}
}
10.19 内部类分类及成员内部类的使用
按照内部类在类中定义的位置不同，可以分为如下两种格式:
在成员位置称为成员内部类
在局部位置称为局部内部类
例:
class Outer
{
//成员内部类
class Inner
{
}
public void method()
{
//局部内部类
class Inner
{
}
}
}
外界创建成员内部类对象的格式:
外部类名.内部类名对象名 = 外部类对象.内部类对象;
例:
class Outer
{
private int num = 10;
//成员内部类
class Inner
{
public void show()
{
System.out.println(num);
}
}
}
class Demo
{
public static void main(String[] args)
{
//访问Inner类的show()方法
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
10.20 成员内部类的常见修饰符及应用
成员内部类的常见修饰符
1.private 为了保证数据的安全性
例:
class Outer
{
//成员内部类，私有
private class Inner
{
public void show()
{
System.out.println("满足条件输出");
}
}
public void method(int num)
{
if(num > 0)
{
Inner i = new Inner();
i.show();
}
}
}
class Demo
{
public static void main(String[] args)
{
Outer o = new Outer();
o.method(-8);
}
}
上例中，只有当method方法传入的参数大于0时，才可以创建内部类的对象调用方法，否则不创建
2.static 为了让数据访问更方便
- 被静态修饰的成员内部类只能访问外部类的静态成员
- 内部类被静态修饰后的方法可以有静态方法也可以有非静态方法
例:
class Outer
{
private static int num = 10;
//成员内部类，静态
public static class Inner
{
//静态方法
public static void show1()
{
System.out.println(num);
}
//非静态方法
public void show2()
{
System.out.println(num);
}
}
}
class Demo
{
public static void main(String[] args)
{
//成员内部类被静态修饰后的访问方式:
//外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show1();
oi.show2(); //静态方法show1()的另一种调用方式
Outer.Inner.show1();
}
}
10.21 成员内部类的面试题
分别输出30、20、10
class Outer
{
public int num = 10;
class Inner
{
public int num = 20;
public void show()
{
int num = 30;
System.out.println(num);//
System.out.println(this.num);//
System.out.println(new Outer().num);//
System.out.println(Outer.this.num);//
}
}
}
class Demo
{
public static void main(String[] args)
{
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
10.22 局部内部类访问局部变量的问题
1.可以直接访问外部类的成员
2.在局部位置可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
例:
class Outer
{
private int num = 10;
public void method()
{
//局部内部类
class Inner
{
public void show()
{
//可以直接访问外部类的成员
System.out.println(num);
}
}
//在局部位置创建内部类对象
Inner i = new Inner();
//通过对象调用内部类方法
i.show();
}
}
class Demo
{
public static void main(String[] args)
{
Outer o = new Outer();
o.method();
}
}
局部内部类访问局部变量的注意事项:
例:
class Outer
{
public void method()
{
//局部变量
final int num = 20;
//局部内部类
class Inner
{
public void show()
{
//局部内部类访问局部变量，该局部变量必须被声明为最终类型
System.out.println(num);
}
} Inner i = new Inner();
i.show();
}
}
class Demo
{
public static void main(String[] args)
{
Outer o = new Outer();
o.method();
}
}
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
10.23 匿名内部类的格式和理解
匿名内部类就是内部类的简化写法。
前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类。
格式:new 类名或者接口名() {重写方法;}
本质:是一个继承了该类或者实现了该接口的子类匿名对象
例:
10.24 匿名内部类的方法调用
例:
interface Inter
{
public abstract void show1();
public abstract void show2();
}
class Outer
{
public void method()
{
/* 一个方法的调用
new Inter()
{
public void show1()
{
System.out.println("show1");
}
}.show1();
*/
//两个方法的调用
Inter i = new Inter()
{
public void show1()
{
System.out.println("show1");
}
public void show2()
{
System.out.println("show2");
}
};
i.show1();
i.show2();
}
}
class Demo
{
public static void main(String[] args)
{
Outer o = new Outer();
o.method();
}
}
10.25 匿名内部类在开发中的应用
例:
interface Person
{
public abstract void study();
}
class PersonDemo
{
public void method(Person p)
{
p.study();
}
}
class Demo
{
public static void main(String[] args)
{
PersonDemo pd = new PersonDemo();
pd.method(new Person()
{
public void study()
{
System.out.println("好好学习");
}
});
}
}
当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递
10.26 匿名内部类的面试题
按照要求，补齐代码，要求在控制台输出”HelloWorld”
interface Inter
{
void show();
}
class Outer
{
//补齐代码
}
class Demo
{
public static void main(String[] args)
{
Outer.method().show();
}
}
补齐代码:
/*
分析:
1:Outer.method()可以看出method()是Outer中的一个静态方法
2:Outer.method().show()可以看出method()方法的返回值是一个对象。
又由于接口Inter中有一个show()方法,所以method()方法的返回值类型是一个接口。
*/
interface Inter
{
void show();
}
class Outer
{
//补齐代码
public static Inter method()
{
return new Inter()
{
public void show()
{
System.out.println("helloworld");
}
};
}
}
class Demo
{
public static void main(String[] args)
{
Outer.method().show();
}
}