你需要的是什么，直接评论留言。
分享是一种美德，分享更快乐！
类,抽象类,接口的综合小练习
/*
教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。
整个分析过程，我是通过画图讲解的。
*/
//定义一个说英语的接口
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) {
public int getage() {
return age;
public void setage(int 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) {
//教
public abstract void teach();
//定义乒乓球运动员具体类
class pingpangplayer extends player implements speakenglish {
public pingpangplayer(){}
public pingpangplayer(string name,int 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) {
system.out.println("篮球运动员吃牛肉，喝牛奶");
system.out.println("篮球运动员学习如何运球和投篮");
//定义乒乓球教练具体类
class pingpangcoach extends coach implements speakenglish {
public pingpangcoach(){}
public pingpangcoach(string name,int age) {
system.out.println("乒乓球教练吃小白菜，喝大米粥");
public void teach() {
system.out.println("乒乓球教练教如何发球和接球");
system.out.println("乒乓球教练说英语");
//定义篮球教练具体类
class basketballcoach extends coach {
public basketballcoach(){}
public basketballcoach(string name,int age) {
system.out.println("篮球教练吃羊肉，喝羊奶");
system.out.println("篮球教练教如何运球和投篮");
class interfacedemo {
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(); //没有该方法
//测试教练自己做
1:形式参数和返回值的问题(理解)
(1)形式参数：
类名：需要该类的对象
抽象类名：需要该类的子类对象
接口名：需要该接口的实现类对象
形式参数：
基本类型(太简单，不是我今天要讲解的)
引用类型
类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象
抽象类:
接口
class student {
system.out.println("good good study,day day up");
class studentdemo {
public void method(student s) { //ss; ss = new student(); student s = new student();
s.study();
class studenttest {
//需求：我要测试student类的study()方法
student s = new student();
//需求2：我要测试studentdemo类中的method()方法
studentdemo sd = new studentdemo();
student ss = new student();
sd.method(ss);
//匿名对象用法
new studentdemo().method(new student());
类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
class persondemo {
public void method(person p) {//p; p = new student(); person p = new student(); //多态
p.study();
//定义一个具体的学生类
class student extends person {
class persontest {
//目前是没有办法的使用的
//因为抽象类没有对应的具体类
//那么，我们就应该先定义一个具体类
//需求：我要使用persondemo类中的method()方法
persondemo pd = new persondemo();
person p = new student();
pd.method(p);
接口:需要的是该接口的实现类对象
//定义一个爱好的接口
interface love {
public abstract void love();
class lovedemo {
public void method(love l) { //l; l = new teacher(); love l = new teacher(); 多态
l.love();
//定义具体类实现接口
class teacher implements love {
public void love() {
system.out.println("老师爱学生,爱java,爱林青霞");
class teachertest {
//需求：我要测试lovedemo类中的love()方法
lovedemo ld = new lovedemo();
love l = new teacher();
ld.method(l);
(2)返回值类型：
类名：返回的是该类的对象
抽象类名：返回的是该类的子类对象
接口名：返回的是该接口的实现类的对象
返回值类型
基本类型:(基本类型太简单，我不准备讲解)
引用类型：
类:返回的是该类的对象
接口:
public student getstudent() {
//student s = new student();
//student ss = s;
//return s;
return new student();
class studenttest2 {
//需求：我要使用student类中的study()方法
//但是，这一次我的要求是，不要直接创建student的对象
//让你使用studentdemo帮你创建对象
student s = sd.getstudent(); //new student(); student s = new student();
抽象类:返回的是该抽象类的子类对象
public person getperson() {
//person p = new student();
//return p;
class persontest2 {
//需求：我要测试person类中的study()方法
person p = pd.getperson(); //new student(); person p = new student(); 多态
接口:返回的是该接口的实现类的对象
public love getlove() {
//love l = new teacher();
//return l;
return new teacher();
class teachertest2 {
//如何测试呢?
love l = ld.getlove(); //new teacher(); love l = new teacher(); 多态
(3)链式编程
对象.方法1().方法2().......方法n();
这种用法：其实在方法1()调用完毕后，应该一个对象；
方法2()调用完毕后，应该返回一个对象。
方法n()调用完毕后，可能是对象，也可以不是对象。
链式编程。
每次调用完毕方法后，返回的是一个对象。
class studenttest3 {
//如何调用的呢?
//student s = sd.getstudent();
//s.study();
//大家注意了
sd.getstudent().study();
2:包(理解)
(1)其实就是文件夹
(2)作用：
a:区分同名的类
b:对类进行分类管理
a:按照功能分
b:按照模块分
包：
a:其实就是文件夹
b:作用
a:把相同的类名放到不同的包中
举例：
学生：增加，删除，修改，查询
老师：增加，删除，修改，查询
...
方案1：按照功能分
cn.itcast.add
addstudent
addteacher
cn.itcast.delete
deletestudent
deleteteacher
cn.itcast.update
updatestudent
updateteacher
cn.itcast.find
findstudent
findteacher
方案2：按照模块分
cn.itcast.teacher
cn.itcast.student
包的定义
package 包名;
多级包用.分开即可
注意事项:
a:package语句必须是程序的第一条可执行的代码
b:package语句在一个java文件中只能有一个
c:如果没有package，默认表示无包名
带包的编译和运行：
a:手动式
a:编写一个带包的java文件。
b:通过javac命令编译该java文件。
c:手动创建包名。
d:把b步骤的class文件放到c步骤的最底层包
e:回到和包根目录在同一目录的地方，然后运行
带包运行。
b:自动式
b:javac编译的时候带上-d即可
javac -d . helloworld.java
c:回到和包根目录在同一目录的地方，然后运行
package cn.itcast;
class helloworld {
system.out.println("helloworld");
(3)包的定义(掌握)
多级包用.分开。
(4)注意事项：(掌握)
a:package语句必须在文件中的第一条有效语句
b:在一个java文件中，只能有一个package
c:如果没有package，默认就是无包名
(5)带包的编译和运行
b:自动式(掌握)
3:导包(掌握)
(1)我们多次使用一个带包的类，非常的麻烦，这个时候，java就提供了一个关键字import。
(2)格式：
import 包名...类名;
另一种：
import 包名...*;(不建议)
(3)package,import,class的顺序
package > import > class
test类，测试
导包：
格式：import 包名;
这种方式导入是到类的名称。
注意：我们用谁就导谁。
面试题：
package,import,class有没有顺序关系?
有。
package:只能有一个
import:可以有多个
class:可以有多个，以后建议是一个
import com.liuyi.demo;
class test {
//demo d = new demo();
com.liuyi.demo d = new com.liuyi.demo();
system.out.println(d.sum(10,20));
com.liuyi.demo d2 = new com.liuyi.demo();
system.out.println(d2.sum(10,20));
com.liuyi.demo d3 = new com.liuyi.demo();
system.out.println(d3.sum(10,20));
com.liuyi.demo d4 = new com.liuyi.demo();
system.out.println(d4.sum(10,20));
demo d = new demo();
第一个问题：找不到demo
第二个问题：程序包com.liuyi不存在
第三个问题： demo在com.liuyi中不是公共的; 无法从外部程序包中对其进行访问
4:权限修饰符(掌握)
(1)权限修饰符
本类同一个包下不同包下的子类不同包下的无关类
privatey
默认yy
protectedyyy
publicyyyy
(2)这四种权限修饰符在任意时刻只能出现一种。
public class demo {}
权限修饰符：
本类同一个包下(子类和无关类)不同包下(子类)不同包下(无关类)
private y
package com.liuyi;
public class father {
private void show() {
system.out.println("show");
void show2() {
system.out.println("show2");
protected void show3() {
system.out.println("show3");
public void show4() {
system.out.println("show4");
father f = new father();
f.show();
f.show2();
f.show3();
f.show4();
5:常见的修饰符(理解)
(1)分类：
权限修饰符：private,默认,protected,public
状态修饰符：static,final
抽象修饰符：abstract
(2)常见的类及其组成的修饰
类：
默认,public,final,abstract
常用的：public
成员变量：
private,默认,protected,public,static,final
常用的：private
构造方法：
private,默认,protected,public
成员方法：
private,默认,protected,public,static,final,abstract
(3)另外比较常见的：
public static final int x = 10;
public static void show() {}
public final void show() {}
public abstract void show();
修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
权限修饰符：默认修饰符，public
状态修饰符：final
用的最多的就是：public
用的最多的就是：private
除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final
//此处不允许使用修饰符private
//此处不允许使用修饰符protected
//此处不允许使用修饰符static
public class demo {
//成员变量
private int x = 10;
int y = 20;
protected int z = 30;
public int a = 40;
public final int b = 50;
public static int c = 60;
public static final int d = 70;
//此处不允许使用修饰符abstract
//abstract int e = 80;
//构造方法
private demo(){}
demo(string name){}
protected demo(string name,int age) {}
public demo(string name,int age,string address) {}
//public static demo(){}
//此处不允许使用修饰符final
//public final demo() {}
//public abstract demo(){}
//成员方法
//static void show() {}
//abstract void show();
//final void show(){}
public class son extends father {
//f.show();
system.out.println("--------------");
son s = new son();
//s.show();
s.show2();
s.show3();
s.show4();
package cn.qx;
import com.liuyi.father;
public class son2 extends father {
//f.show2();
//f.show3();
son2 s = new son2();
//s.show2();
public class test {
class test2 {
6:内部类(理解)
(1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类b定义在类a中，类b就被称为内部类。
(2)内部类的访问规则
a:可以直接访问外部类的成员，包括私有
b:外部类要想访问内部类成员，必须创建对象
内部类概述:
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类a中定义了一个类b，类b就是内部类。
内部的访问特点：
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。
class outer {
private int num = 10;
class inner {
public void show() {
system.out.println(num);
public void method() {
//找不到符号
//show();
inner i = new inner();
i.show();
class innerclassdemo {
(3)内部类的分类
a:成员内部类
b:局部内部类
内部类位置
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
//成员位置
//局部位置
class innerclassdemo2 {
(4)成员内部类
a:private 为了数据的安全性
b:static 为了访问的方便性
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
成员内部类:
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
class innerclassdemo3 {
//需求：我要访问inner类的show()方法
//inner i = new inner();
//i.show();
//格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
outer.inner oi = new outer().new inner();
oi.show();
成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意：静态内部类访问的外部类数据必须用静态修饰。
案例：我有一个人(人有身体，身体内有心脏。)
class body {
private class heart {
public void operator() {
system.out.println("心脏搭桥");
if(如果你是外科医生) {
heart h = new heart();
h.operator();
按照我们刚才的讲解，来使用一下
body.heart bh = new body().new heart();
bh.operator();
//加了private后，就不能被访问了，那么，怎么玩呢?
body b = new body();
b.method();
private static int num2 = 100;
//内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class inner {
//system.out.println(num);
system.out.println(num2);
public static void show2() {
class innerclassdemo4 {
//使用内部类
// 限定的新静态类
//outer.inner oi = new outer().new inner();
//oi.show();
//oi.show2();
//成员内部类被静态修饰后的访问方式是:
//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
outer.inner oi = new outer.inner();
oi.show2();
//show2()的另一种调用方式
outer.inner.show2();
(5)成员内部类的面试题(填空)
30,20,10
public int num = 10;
public int num = 20;
public viod show() {
int num = 30;
system.out.println(this.num);
system.out.println(outer.this.num);
要求请填空分别输出30，20，10。
注意：
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象
outer.this
int num = 30;
//system.out.println(new outer().num);
class innerclasstest {
(6)局部内部类
a:局部内部类访问局部变量必须加final修饰。
b:为什么呢?
因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
局部内部类
a:可以直接访问外部类的成员
b:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
局部内部类访问局部变量的注意事项?
a:局部内部类访问局部变量必须用final修饰
局部变量是随着方法的调用而调用，随着调用完毕而消失。
而堆内存的内容并不会立即消失。所以，我们加final修饰。
加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
我在内存中存储的是数据20，所以，我还是有数据在使用。
private int num = 10;
//int num2 = 20;
//final int num2 = 20;
//从内部类中访问本地变量num2; 需要被声明为最终类型
system.out.println(num2);//20
//system.out.println(num2);
class innerclassdemo5 {
outer o = new outer();
o.method();
(7)匿名内部类(掌握)
a:是局部内部类的简化形式
b:前提
存在一个类或者接口
c:格式:
new 类名或者接口名() {
重写方法;
d:本质：
其实是继承该类或者实现接口的子类匿名对象
匿名内部类
就是内部类的简化写法。
前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式：
new 类名或者接口名(){
本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。
interface inter {
public abstract void show2();
//一个方法的时候
new inter() {
}.show();
//二个方法的时候
public void show2() {
}.show2();
//如果我是很多个方法，就很麻烦了
//那么，我们有没有改进的方案呢?
inter i = new inter() { //多态
};
i.show2();
class innerclassdemo6 {
(8)匿名内部类在开发中的使用
我们在开发的时候，会看到抽象类，或者接口作为参数。
而这个时候，我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
interface person {
public void method(person p) {
pd.method(new person() {
system.out.println("好好学习，天天向上");
});
匿名内部类在开发中的使用
//接口名作为形式参数
//其实这里需要的不是接口，而是该接口的实现类的对象
//实现类
class student implements person {
system.out.println("好好学习,天天向上");
class innerclasstest2 {
//测试
system.out.println("--------------------");
//匿名内部类在开发中的使用
//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new person(){
(9)匿名内部类的面试题(补齐代码)
void show();
//补齐代码
public static inter method() {
return new inter() {
class outerdemo {
outer.method().show(); //"helloworld"
匿名内部类面试题：
按照要求，补齐代码
interface inter { void show(); }
class outer { //补齐代码 }
outer.method().show();
}
要求在控制台输出”helloworld”
interface inter {
void show();
//public abstract
class outer {
//子类对象 -- 子类匿名对象
outer.method().show();
1:outer.method()可以看出method()应该是outer中的一个静态方法。
2:outer.method().show()可以看出method()方法的返回值是一个对象。
又由于接口inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
java帮帮交流群