抽象类与接口的相关知识

 

抽象类概述

回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。

    为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

 

 

抽象类特点

抽象类特点

抽象类和抽象方法必须用abstract关键字修饰

   格式

      abstract class 类名 {}

      public abstract void eat();

 

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

 

抽象类不能实例化

那么，抽象类如何实例化呢?

     按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

 

抽象类的子类

  要么是抽象类

  要么重写抽象类中的所有抽象方法

 

案例：

 

 

/*

抽象类的概述：

动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。

我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。

抽象类的特点：

A:抽象类和抽象方法必须用abstract关键字修饰

B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类

C:抽象类不能实例化

因为它不是具体的。

抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?

用于子类访问父类数据的初始化

D:抽象的子类

a:如果不想重写抽象方法，该子类是一个抽象类。

b:重写所有的抽象方法，这个时候子类是一个具体的类。

抽象类的实例化其实是靠具体的子类实现的。是多态的方式。

Animal a = new Cat();

*/

 

//abstract class Animal //抽象类的声明格式

abstract class Animal 4{

//抽象方法

//public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体

public abstract void eat();

public Animal(){}

}

 

//子类是抽象类

abstract class Dog extends Animal {}

 

//子类是具体类，重写抽象方法

class Cat extends Animal {

public void eat() {

System.out.println("猫吃鱼");

}

}

 

class AbstractDemo {

public static void main(String[] args) {

//创建对象

//Animal是抽象的; 无法实例化

//Animal a = new Animal();

//通过多态的方式

Animal a = new Cat();

a.eat();

 

}

}

 

 

抽象类成员的特点

/*

抽象类的成员特点：

成员变量：既可以是变量，也可以是常量。

构造方法：有。

用于子类访问父类数据的初始化。

成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：

A:抽象方法 强制要求子类做的事情。

B:非抽象方法 子类继承的事情，提高代码复用性。

*/

abstract class Animal {

public int num = 10;

public final int num2 = 20;

 

public Animal() {}

public Animal(String name,int age){}

public abstract void show();

public void method() {

System.out.println("method");

}

}

 

class Dog extends Animal {

public void show() {

System.out.println("show Dog");

}

}

 

class AbstractDemo2 {

public static void main(String[] args) {

//创建对象

Animal a = new Dog();

a.num = 100;

System.out.println(a.num);

//a.num2 = 200;

System.out.println(a.num2);

System.out.println("--------------");

a.show();

a.method();

}

}

 

总结：

成员变量

  可以是变量

  也可以是常量

构造方法

  有构造方法，但是不能实例化

  那么，构造方法的作用是什么呢?

    用于子类访问父类数据的初始化

成员方法

  可以有抽象方法 限定子类必须完成某些动作

  也可以有非抽象方法 提高代码服用性

 

 

抽象类练习

猫狗案例

具体事物：猫，狗

共性：姓名，年龄，吃饭

 

/*

猫狗案例

具体事物：猫，狗

共性：姓名，年龄，吃饭

 

分析：从具体到抽象

猫:

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：吃饭(猫吃鱼)

狗:

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：吃饭(狗吃肉)

因为有共性的内容，所以就提取了一个父类。动物。

但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，

而方法是抽象的类，类就必须定义为抽象类。

抽象动物类：

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：吃饭();

实现：从抽象到具体

动物类:

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：吃饭();

狗类：

继承自动物类

重写吃饭();

猫类：

继承自动物类

重写吃饭();

*/

//定义抽象的动物类

abstract class Animal {

//姓名

private String name;

//年龄

private int age;

public Animal() {}

public Animal(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 abstract void eat();

}

 

//定义具体的狗类

class Dog extends Animal {

public Dog() {}

public Dog(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("狗吃肉");

}

}

 

//定义具体的猫类

class Cat extends Animal {

public Cat() {}

public Cat(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("猫吃鱼");

}

}

 

//测试类

class AbstractTest {

public static void main(String[] args) {

//测试狗类

//具体类用法

//方式1：

Dog d = new Dog();

d.setName("旺财");

d.setAge(3);

System.out.println(d.getName()+"---"+d.getAge());

d.eat();

//方式2：

Dog d2 = new Dog("旺财",3);

System.out.println(d2.getName()+"---"+d2.getAge());

d2.eat();

System.out.println("---------------------------");

Animal a = new Dog();

a.setName("旺财");

a.setAge(3);

System.out.println(a.getName()+"---"+a.getAge());

a.eat();

Animal a2 = new Dog("旺财",3);

System.out.println(a2.getName()+"---"+a2.getAge());

a2.eat();

//练习：测试猫类

}

}

 

 

老师案例

具体事物：基础班老师，就业班老师

共性：姓名，年龄，讲课。

 

/*

老师案例

具体事物：基础班老师，就业班老师

共性：姓名，年龄，讲课。

 

分析：

基础班老师

姓名，年龄

讲课。

就业班老师

姓名，年龄

讲课。

实现：

老师类

基础班老师

就业班老师

*/

//定义抽象的老师类

abstract class Teacher {

//姓名

private String name;

//年龄

private int age;

public Teacher() {}

public Teacher(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 abstract void teach();

}

 

//基础班老师类

class BasicTeacher extends Teacher {

public BasicTeacher(){}

public BasicTeacher(String name,int age) {

super(name,age);

}

public void teach() {

System.out.println("基础班老师讲解JavaSE");

}

}

 

//就业班老师类

class WorkTeacher extends Teacher {

public WorkTeacher(){}

public WorkTeacher(String name,int age) {

super(name,age);

}

public void teach() {

System.out.println("就业班老师讲解JavaEE");

}

}

 

class AbstractTest2 {

public static void main(String[] args) {

//具体的类测试，自己玩

//测试(多态)

//基础班老师

Teacher t = new BasicTeacher();

t.setName("张三");

t.setAge(30);

System.out.println(t.getName()+"---"+t.getAge());

t.teach();

System.out.println("--------------");

t = new BasicTeacher("张三",30);

System.out.println(t.getName()+"---"+t.getAge());

t.teach();

System.out.println("--------------");

//就业班老师

t = new WorkTeacher();

t.setName("林青霞");

t.setAge(27);

System.out.println(t.getName()+"---"+t.getAge());

t.teach();

System.out.println("--------------");

t = new WorkTeacher("林青霞",27);

System.out.println(t.getName()+"---"+t.getAge());

t.teach();

}

}

 

 

学生案例

具体事务：基础班学员，就业班学员

共性：姓名，年龄，班级，学习，吃饭

/*

学生案例

具体事务：基础班学员，就业班学员

共性：姓名，年龄，班级，学习，吃饭

 

分析：

基础班学员

成员变量：姓名，年龄，班级

成员方法：学习，吃饭

就业班学员

成员变量：姓名，年龄，班级

成员方法：学习，吃饭

得到一个学员类。

成员变量：姓名，年龄，班级

成员方法：学习，吃饭

实现：

学员类

基础班学员

就业班学员

*/

//定义抽象学员类

abstract class Student {

//姓名

private String name;

//年龄

private int age;

//班级

private String grand;

public Student() {}

public Student(String name,int age,String grand) {

this.name = name;

this.age = age;

this.grand = grand;

}

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 String getGrand() {

return grand;

}

public void setGrand(String grand) {

this.grand = grand;

}

//学习

public abstract void study();

//吃饭

public void eat() {

System.out.println("学习累了,就该吃饭");

}

}

 

//具体基础班学员类

class BasicStudent extends Student {

public BasicStudent() {}

public BasicStudent(String name,int age,String grand) {

super(name,age,grand);

}

public void study() {

System.out.println("基础班学员学习的是JavaSE");

}

}

 

//具体就业班学员类

class WorkStudent extends Student {

public WorkStudent() {}

public WorkStudent(String name,int age,String grand) {

super(name,age,grand);

}

public void study() {

System.out.println("就业班学员学习的是JavaEE");

}

}

 

class AbstractTest3 {

public static void main(String[] args) {

//我仅仅测试基础班学员

//按照多态的方式测试

Student s = new BasicStudent();

s.setName("林青霞");

s.setAge(27);

s.setGrand("1111");

System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());

s.study();

s.eat();

System.out.println("--------------");

s = new BasicStudent("王世昌",48,"1111");

System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());

s.study();

s.eat();

//就业班测试留给自己玩

}

}

 

员工案例

假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。

经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。

 

/*

假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。

经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。

请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

分析：

普通员工类

成员变量：姓名、工号以及工资。

成员方法：工作

经理类：

成员变量：姓名、工号以及工资，奖金属性

成员方法：工作

实现：

员工类：

普通员工类：

经理类：

*/

//定义员工类

abstract class Employee {

//姓名、工号以及工资

private String name;

private String id;

private int salary;

public Employee() {}

public Employee(String name,String id,int salary) {

this.name = name;

this.id = id;

this.salary = salary;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public int getSalary() {

return salary;

}

public void setSalary(int salary) {

this.salary = salary;

}

//工作

public abstract void work();

}

 

//普通员工类

class Programmer extends Employee {

public Programmer(){}

public Programmer(String name,String id,int salary) {

super(name,id,salary);

}

public void work() {

System.out.println("按照需求写代码");

}

}

 

//经理类

class Manager extends Employee {

//奖金

private int money; //bonus 奖金

 

public Manager(){}

public Manager(String name,String id,int salary,int money) {

super(name,id,salary);

this.money = money;

}

public void work() {

System.out.println("跟客户谈需求");

}

public int getMoney() {

return money;

}

public void setMoney(int money) {

this.money = money;

}

}

 

class AbstractTest4 {

public static void main(String[] args) {

//测试普通员工

Employee emp = new Programmer();

emp.setName("林青霞");

emp.setId("czbk001");

emp.setSalary(18000);

System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());

emp.work();

System.out.println("-------------");

emp = new Programmer("林青霞","czbk001",18000);

System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());

emp.work();

System.out.println("-------------");

/*

emp = new Manager();

emp.setName("张长志");

emp.setId("czbk002");

emp.setSalary(8000);

emp.setMoney(2000);

*/

//由于子类有特有的内容，所以我们用子类来测试

Manager m = new Manager();

m.setName("张长志");

m.setId("czbk002");

m.setSalary(8000);

m.setMoney(2000);

System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());

m.work();

System.out.println("-------------");

//通过构造方法赋值

m = new Manager("张长志","czbk002",8000,2000);

System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());

m.work();

}

}

 

抽象类的几个小问题

/*

一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

A:可以。

B:不让创建对象。

 

abstract不能和哪些关键字共存?

private冲突

final冲突

    Static 无意义

*/

abstract class Fu {

//public abstract void show();

//非法的修饰符组合: abstract和private

//private abstract void show();

//非法的修饰符组合

//final abstract void show();

}

 

class Zi extends Fu {

public void show() {}

}

 

class AbstractDemo3 {

public static void main(String[] args) {

}

}

 

 

接口的引入

继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，对不。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的，对不。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

 

 

接口特点

 

接口用关键字interface表示

     格式：interface 接口名 {}

类实现接口用implements表示

   格式：class 类名 implements 接口名 {}

接口不能实例化

    那么，接口如何实例化呢?

    按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

接口的子类

   要么是抽象类

   要么重写接口中的所有抽象方法

 

/*

接口的特点：

A:接口用关键字interface表示

interface 接口名 {}

B:类实现接口用implements表示

class 类名 implements 接口名 {}

C:接口不能实例化

那么，接口如何实例化呢?

按照多态的方式来实例化。

D:接口的子类

a:可以是抽象类。但是意义不大。

b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

由此可见：

A:具体类多态(几乎没有)

B:抽象类多态(常用)

C:接口多态(最常用)

*/

//定义动物培训接口

interface AnimalTrain {

public abstract void jump();

}

 

//抽象类实现接口

abstract class Dog implements AnimalTrain {

}

 

//具体类实现接口

class Cat implements AnimalTrain {

public void jump() {

System.out.println("猫可以跳高了");

}

}

 

class InterfaceDemo {

public static void main(String[] args) {

//AnimalTrain是抽象的; 无法实例化

//AnimalTrain at = new AnimalTrain();

//at.jump();

AnimalTrain at = new Cat();

at.jump();

}

}

 

 

接口成员特点

成员变量

  只能是常量

  默认修饰符 public static final

构造方法

   没有，因为接口主要是扩展功能的，而没有具体存在

成员方法

   只能是抽象方法

   默认修饰符 public abstract

/*

接口成员特点

成员变量；只能是常量，并且是静态的。

默认修饰符：public static final

建议：自己手动给出。

构造方法：接口没有构造方法。

成员方法：只能是抽象方法。

默认修饰符：public abstract

建议：自己手动给出。

所有的类都默认继承自一个类：Object。

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

*/

interface Inter {

public int num = 10;

public final int num2 = 20;

public static final int num3 = 30;

//错误: 需要<标识符>

//public Inter() {}

//接口方法不能带有主体

//public void show() {}

 

//abstract void show(); //默认public

public void show(); //默认abstract

}

 

//接口名+Impl这种格式是接口的实现类格式

/*

class InterImpl implements Inter {

public InterImpl() {

super();

}

}

*/

 

class InterImpl extends Object implements Inter {

public InterImpl() {

super();

}

public void show() {}

}

 

//测试类

class InterfaceDemo2 {

public static void main(String[] args) {

//创建对象

Inter i = new InterImpl();

System.out.println(i.num);

System.out.println(i.num2);

//i.num = 100;

//i.num2 = 200;

//System.out.println(i.num); //无法为最终变量num分配值

//System.out.println(i.num2);//无法为最终变量num2分配值

System.out.println(Inter.num);

System.out.println(Inter.num2);

System.out.println("--------------");

}

}

 

类与类,类与接口以及接口与接口的关系

类与类

  继承关系，只能单继承，但是可以多层继承

类与接口

  实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口

  继承关系，可以单继承，也可以多继承

 

/*

类与类：

继承关系,只能单继承,可以多层继承。

类与接口：

实现关系,可以单实现,也可以多实现。

并且还可以在继承一个类的同时实现多个接口。

接口与接口：

继承关系,可以单继承,也可以多继承。

*/

interface Father {

public abstract void show();

}

 

interface Mother {

public abstract void show2();

}

 

interface Sister extends Father,Mother {

 

}

 

//class Son implements Father,Mother //多实现

class Son extends Object implements Father,Mother {

public void show() {

System.out.println("show son");

}

public void show2() {

System.out.println("show2 son");

}

}

 

class InterfaceDemo3 {

public static void main(String[] args) {

//创建对象

Father f = new Son();

f.show();

//f.show2(); //报错

Mother m = new Son();

//m.show(); //报错

m.show2();

}

}

 

 

抽象类和接口的区别

 

成员区别

   抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法

   接口 常量;抽象方法

关系区别

   类与类 继承，单继承

   类与接口 实现，单实现，多实现

   接口与接口 继承，单继承，多继承

设计理念区别

   抽象类 被继承体现的是：”is a”的关系。共性功能

   接口 被实现体现的是：”like a”的关系。扩展功能

 

 

接口练习

猫狗案例,加入跳高的额外功能

 

/*

猫狗案例,加入跳高的额外功能

分析：从具体到抽象

猫：

姓名,年龄

吃饭，睡觉

狗：

姓名,年龄

吃饭，睡觉

由于有共性功能，所以，我们抽取出一个父类：

动物：

姓名,年龄

吃饭();

睡觉(){}

猫：继承自动物

狗：继承自动物

跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口

接口：

跳高

部分猫：实现跳高

部分狗：实现跳高

实现；

从抽象到具体

使用：

使用具体类

*/

//定义跳高接口

interface Jumpping {

//跳高功能

public abstract void jump();

}

 

//定义抽象类

abstract class Animal {

//姓名

private String name;

//年龄

private int age;

public Animal() {}

public Animal(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 abstract void eat();

//睡觉(){}

public void sleep() {

System.out.println("睡觉觉了");

}

}

 

//具体猫类

class Cat extends Animal {

public Cat(){}

public Cat(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("猫吃鱼");

}

}

 

//具体狗类

class Dog extends Animal {

public Dog(){}

public Dog(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("狗吃肉");

}

}

 

//有跳高功能的猫

class JumpCat extends Cat implements Jumpping {

public JumpCat() {}

public JumpCat(String name,int age) {

super(name,age);

}

 

public void jump() {

System.out.println("跳高猫");

}

}

 

//有跳高功能的狗

class JumpDog extends Dog implements Jumpping {

public JumpDog() {}

public JumpDog(String name,int age) {

super(name,age);

}

 

public void jump() {

System.out.println("跳高狗");

}

}

 

class InterfaceTest {

public static void main(String[] args) {

//定义跳高猫并测试

JumpCat jc = new JumpCat();

jc.setName("哆啦A梦");

jc.setAge(3);

System.out.println(jc.getName()+"---"+jc.getAge());

jc.eat();

jc.sleep();

jc.jump();

System.out.println("-----------------");

JumpCat jc2 = new JumpCat("加菲猫",2);

System.out.println(jc2.getName()+"---"+jc2.getAge());

jc2.eat();

jc2.sleep();

jc2.jump();

//定义跳高狗并进行测试的事情自己完成。

}

}

 

 

老师和学生案例,加入抽烟的额外功能

 

/*

老师和学生案例,加入抽烟的额外功能

分析：从具体到抽象

老师：姓名，年龄，吃饭，睡觉

学生：姓名，年龄，吃饭，睡觉

由于有共性功能，我们提取出一个父类，人类。

人类：

姓名，年龄

吃饭();

睡觉(){}

抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

抽烟接口。

 

部分老师抽烟：实现抽烟接口

部分学生抽烟：实现抽烟接口

实现：从抽象到具体

使用：具体

*/

//定义抽烟接口

interface Smoking {

//抽烟的抽象方法

public abstract void smoke();

}

 

//定义抽象人类

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 abstract void eat();

//睡觉(){}

public void sleep() {

System.out.println("睡觉觉了");

}

}

 

//具体老师类

class Teacher extends Person {

public Teacher() {}

public Teacher(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("吃大白菜");

}

}

 

//具体学生类

class Student extends Person {

public Student() {}

public Student(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("吃红烧肉");

}

}

 

//抽烟的老师

class SmokingTeacher extends Teacher implements Smoking {

public SmokingTeacher() {}

public SmokingTeacher(String name,int age) {

super(name,age);

}

 

public void smoke() {

System.out.println("抽烟的老师");

}

}

 

//抽烟的学生

class SmokingStudent extends Student implements Smoking {

public SmokingStudent() {}

public SmokingStudent(String name,int age) {

super(name,age);

}

 

public void smoke() {

System.out.println("抽烟的学生");

}

}

 

class InterfaceTest2 {

public static void main(String[] args) {

//测试学生

SmokingStudent ss = new SmokingStudent();

ss.setName("林青霞");

ss.setAge(27);

System.out.println(ss.getName()+"---"+ss.getAge());

ss.eat();

ss.sleep();

ss.smoke();

System.out.println("-------------------");

SmokingStudent ss2 = new SmokingStudent("张长志",30);

System.out.println(ss2.getName()+"---"+ss2.getAge());

ss2.eat();

ss2.sleep();

ss2.smoke();

//测试老师留给自己练习

}

}

 

 

 

教练和运动员案例

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识：

分析，这个案例中有哪些抽象类，哪些接口，哪些具体类

 

 

 

 

/*

教练和运动员案例(学生分析然后讲解)

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识：

分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

整个分析过程，我是通过画图讲解的。

*/

//定义一个说英语的接口

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 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(); //没有该方法

//测试教练自己做

}

}

 

形式参数和返回值问题案例

 

形式参数

  基本类型

  引用类型

返回值类型

  基本类型

  引用类型

链式编程

 

 

案例一类名

 

/*

形式参数：

基本类型(太简单，不是我今天要讲解的)

引用类型

类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象

抽象类:

接口

*/

class Student {

public void study() {

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 {

public static void main(String[] args) {

//需求：我要测试Student类的study()方法

Student s = new Student();

s.study();

System.out.println("----------------");

//需求2：我要测试StudentDemo类中的method()方法

StudentDemo sd = new StudentDemo();

Student ss = new Student();

sd.method(ss);

System.out.println("----------------");

//匿名对象用法

new StudentDemo().method(new Student());

}

}

 

 

抽象类

/*

形式参数：

基本类型(太简单，不是我今天要讲解的)

引用类型

类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象

抽象类:需要的是该抽象的类子类对象

接口

*/

abstract class Person {

public abstract void study();

}

 

class PersonDemo {

public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态

p.study();

}

}

 

//定义一个具体的学生类

class Student extends Person {

public void study() {

System.out.println("Good Good Study,Day Day Up");

}

}

 

class PersonTest {

public static void main(String[] args) {

//目前是没有办法的使用的

//因为抽象类没有对应的具体类

//那么，我们就应该先定义一个具体类

//需求：我要使用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 {

public static void main(String[] args) {

//需求：我要测试LoveDemo类中的love()方法

LoveDemo ld = new LoveDemo();

Love l = new Teacher();

ld.method(l);

}

}

 

类名作为返回值

/*

返回值类型

基本类型:(基本类型太简单，我不准备讲解)

引用类型：

类:返回的是该类的对象

抽象类:

接口:

*/

class Student {

public void study() {

System.out.println("Good Good Study,Day Day Up");

}

}

 

class StudentDemo {

public Student getStudent() {

//Student s = new Student();

//Student ss = s;

//Student s = new Student();

//return s;

return new Student();

}

}

 

class StudentTest2 {

public static void main(String[] args) {

//需求：我要使用Student类中的study()方法

//但是，这一次我的要求是，不要直接创建Student的对象

//让你使用StudentDemo帮你创建对象

StudentDemo sd = new StudentDemo();

Student s = sd.getStudent(); //new Student(); Student s = new Student();

s.study();

}

}

 

 

抽象类作为返回值

/*

返回值类型

基本类型:(基本类型太简单，我不准备讲解)

引用类型：

类:返回的是该类的对象

抽象类:返回的是该抽象类的子类对象

接口:

*/

abstract class Person {

public abstract void study();

}

 

class PersonDemo {

public Person getPerson() {

//Person p = new Student();

//return p;

return new Student();

}

}

 

class Student extends Person {

public void study() {

System.out.println("Good Good Study,Day Day Up");

}

}

 

class PersonTest2 {

public static void main(String[] args) {

//需求：我要测试Person类中的study()方法

PersonDemo pd = new PersonDemo();

Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态

p.study();

}

}

 

 

接口作为返回值

/*

返回值类型

基本类型:(基本类型太简单，我不准备讲解)

引用类型：

类:返回的是该类的对象

抽象类:返回的是该抽象类的子类对象

接口:返回的是该接口的实现类的对象

*/

//定义一个爱好的接口

interface Love {

public abstract void love();

}

 

class LoveDemo {

public Love getLove() {

//Love l = new Teacher();

//return l;

return new Teacher();

}

}

 

//定义具体类实现接口

class Teacher implements Love {

public void love() {

System.out.println("老师爱学生,爱Java,爱林青霞");

}

}

 

class TeacherTest2 {

public static void main(String[] args) {

//如何测试呢?

LoveDemo ld = new LoveDemo();

Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态

l.love();

}

}

 

链式编程

/*

链式编程。

每次调用完毕方法后，返回的是一个对象。

*/

class Student {

public void study() {

System.out.println("Good Good Study,Day Day Up");

}

}

 

class StudentDemo {

public Student getStudent() {

return new Student();

}

}

 

class StudentTest3 {

public static void main(String[] args) {

//如何调用的呢?

StudentDemo sd = new StudentDemo();

//Student s = sd.getStudent();

//s.study();

//大家注意了

sd.getStudent().study();

}

}