09(02)总结final,多态,抽象类,接口

(4)抽象类的练习

A:猫狗案例练习

B:老师案例练习

C:学生案例练习

D:员工案例练习

/*  A:
 猫狗案例
 具体事物:猫,狗
 共性:姓名,年龄,吃饭
 分析:从具体到抽象
 猫:
 成员变量:姓名,年龄
 构造方法:无参,带参
 成员方法:吃饭(猫吃鱼)
 狗:
 成员变量:姓名,年龄
 构造方法:无参,带参
 成员方法:吃饭(狗吃肉)
 因为有共性的内容,所以就提取了一个父类。动物。
 但是又由于吃饭的内容不一样,所以吃饭的方法是抽象的,
 而方法是抽象的类,类就必须定义为抽象类。
 抽象动物类:
 成员变量:姓名,年龄
 构造方法:无参,带参
 成员方法:吃饭();
 实现:从抽象到具体
 动物类:
 成员变量:姓名,年龄
 构造方法:无参,带参
 成员方法:吃饭();
 狗类:
 继承自动物类
 重写吃饭();
 猫类:
 继承自动物类
 重写吃饭();
*/
//定义抽象的动物类
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();
 //练习:测试猫类
 }
}
/*   B:
 老师案例
 具体事物:基础班老师,就业班老师
 共性:姓名,年龄,讲课。
 分析: 
 基础班老师
 姓名,年龄
 讲课。
 就业班老师
 姓名,年龄
 讲课。
 实现:
 老师类
 基础班老师
 就业班老师
*/
//定义抽象的老师类
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();
 }
}
/*   C:
 学生案例
 具体事务:基础班学员,就业班学员
 共性:姓名,年龄,班级,学习,吃饭
 分析:
 基础班学员
 成员变量:姓名,年龄,班级
 成员方法:学习,吃饭
 就业班学员
 成员变量:姓名,年龄,班级
 成员方法:学习,吃饭
 得到一个学员类。
 成员变量:姓名,年龄,班级
 成员方法:学习,吃饭
 实现:
 学员类
 基础班学员
 就业班学员
*/
//定义抽象学员类
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();
 //就业班测试留给自己玩
 }
}
/*  D:
 假如我们在开发一个系统时需要对员工类进行设计,员工包含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();
 }
}
 (5)抽象类的几个小问题
 A:抽象类有构造方法,不能实例化,那么构造方法有什么用?
 用于子类访问父类数据的初始化
 B:一个类如果没有抽象方法,却定义为了抽象类,有什么用?
 为了不让创建对象
 C:abstract不能和哪些关键字共存
 a:final 冲突
 b:private 冲突
 c:static 无意义
/*
一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
 A:可以。
 B:不让创建对象。
abstract不能和哪些关键字共存?
 private 冲突
 final 冲突 
 static 无意义
*/
abstract class Fu {
 //public abstract void show();
 //非法的修饰符组合: abstract和private
 //private abstract void show();
 //非法的修饰符组合
 //final abstract void show(); 
 //非法的修饰符组合
 static abstract void show();
 public static void method() {
 System.out.println("method");
 }
}
class Zi extends Fu {
 public void show() {}
}
class AbstractDemo3 {
 public static void main(String[] args) {
 Fu.method();
 }
}
4:接口(掌握)
 (1)回顾猫狗案例,它们仅仅提供一些基本功能。
    比如:猫钻火圈,狗跳高等功能,不是动物本身就具备的,
    是在后面的培养中训练出来的,这种额外的功能,java提供了接口表示。
 (2)接口的特点:
 A:接口用关键字interface修饰
 interface 接口名 {}
 B:类实现接口用implements修饰
 class 类名 implements 接口名 {}
 C:接口不能实例化
 D:接口的实现类
 a:是一个抽象类。
 b:是一个具体类,这个类必须重写接口中的所有抽象方法。
/*
 接口的特点:
 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();
 }
}

(3)接口的成员特点:

A:成员变量

只能是常量

默认修饰符:public static final

B:构造方法

没有构造方法

C:成员方法

只能是抽象的

默认修饰符: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("--------------");

}

}

(4)类与类,类与接口,接口与接口

A:类与类

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

B:类与接口

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

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

C:接口与接口

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

/*

类与类:

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

类与接口:

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

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

接口与接口:

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

*/

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();

}

}

(5)抽象类和接口的区别

A:成员区别

抽象类:

成员变量:可以变量,也可以常量

构造方法:有

成员方法:可以抽象,也可以非抽象

接口:

成员变量:只可以常量

成员方法:只可以抽象

B:关系区别

类与类

继承,单继承

类与接口

实现,单实现,多实现

接口与接口

继承,单继承,多继承

C:设计理念区别

抽象类 被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系的共性功能。

接口 被实现体现的是:”like a”的关系。接口中定义的是该继承体系的扩展功能。

(6)练习:

A:猫狗案例,加入跳高功能

B:老师和学生案例,加入抽烟功能0

/* 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();
 //定义跳高狗并进行测试的事情自己完成。
 }
}
/*   B:
 老师和学生案例,加入抽烟的额外功能
 分析:从具体到抽象
 老师:姓名,年龄,吃饭,睡觉
 学生:姓名,年龄,吃饭,睡觉
 由于有共性功能,我们提取出一个父类,人类。
 人类:
 姓名,年龄
 吃饭();
 睡觉(){}
 抽烟的额外功能不是人或者老师,或者学生一开始就应该具备的,所以,我们把它定义为接口
 抽烟接口。
 部分老师抽烟:实现抽烟接口
 部分学生抽烟:实现抽烟接口
 实现:从抽象到具体
 使用:具体
*/
//定义抽烟接口
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();
 //测试老师留给自己练习
 }
}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2016-11-29

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏浪淘沙

java设计模式(2) 建造者模式,深复制与浅复制

建造者模式 就是建造不同的东西,但是基本流程不变,将复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 //构建产品 public ...

11730
来自专栏机器学习从入门到成神

几种有关排序的常见面试问题

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_35512245/articl...

24220
来自专栏noteless

正确重写hashcode hashcode与equals方法 集合元素如何判断是否相等 集合如何查看是否包含某个元素

相等的两个对象,即equals(Object)方法判断两个对象相等,那么他们必须要有相同的hashcode

23910
来自专栏Java帮帮-微信公众号-技术文章全总结

【Java提高二】三大特性-继承

【Java提高】三大特性-继承 在《Think in java》中有这样一句话:复用代码是Java众多引人注目的功能之一。但要想成为极具革命性的语言,仅仅能够...

36190
来自专栏技术与生活

Lambda 深入浅出

非常简单,那么问题来了,如果这个时候需求变动,要求选择的是红色的并且重量大于10的,那么怎么办。小 case,不就一行代码的事

14720
来自专栏Golang语言社区

第四节 Go语言数据类型

干货来了!!!为了让更多的小伙伴喜欢Golang、加入Golang之中来,Golang语言社区发起人彬哥联合业界大牛共同推出了Go语言基础、进阶、提高课程,目前...

8620
来自专栏Android知识点总结

再见kotlin--02函数

8820
来自专栏Android相关

Kotlin---扩展

通过data关键字来定义数据类。通常用来定义纯数据类型的结构体。定义的数据类只能有一个主构造函数定义该数据类中的变量。而在该类中,可以定义函数

10230
来自专栏算法channel

程序员必看:实现栈有这两种策略,有完整分析和代码实现

这两篇中分别总结了程序的时间性能度量指标,典型的时间复杂度类型,Java中类型的空间消耗的量化情况。后一篇考虑计算机中最重要的基础算法查找和排序算法,这篇可以说...

11400
来自专栏Java帮帮-微信公众号-技术文章全总结

第十一天 面向对象-接口多态【悟空教程】

16940

扫码关注云+社区

领取腾讯云代金券