抽象类
抽象类:使用关键字abstract修饰的类;
//定义一个抽象类
public abstract class Animal {
}
抽象类的特点:
1.抽象类和抽象方法都必须使用abstract修饰;
//定义抽象类
public abstract class Animal{}
//定义一个抽象方法
public abstract void show();
2.抽象类里面不一定有抽象方法,有抽象方法一定是抽象类;
3.抽象类不能直接实例化,只能使用多态的形式创建对象–子类对象实例化;
4.抽象类的子类:
要么重写抽象类中的所有抽象方法;
要么是抽象类;
抽象类的成员特点
抽象类中可以有成员变量:
可是是变量;
也可以是常量;
可以有构造方法:
有构造方法,但是不能实例化;
构造方法的作用?用于子类访问父类数据的初始化;
可以有成员方法:
可以有抽象方法:限定子类必须完成某些动作;
也可以有非抽象方法:提高代码的复用性;
public abstract class Animal {
private int age = 20;
private final String city = "广东惠州";
//可以定义构造方法
public Animal() {}
//可以定义普通方法
public void show() {
System.out.println(age);
}
//抽象方法
public abstract void eat();
}
猫和狗的案例
//定义抽象动物类Animal
public abstract class Animal {
//成员变量
private int age;
private String name;
//set/get方法
public void setAge(int age) {
this.age = age;
}
public int getAge() {
reteurn age;
}
public setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//无参构造方法
public Animal() {}
//带参构造方法
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
//抽象方法eat()
public abstract eat();
}
//定义一个猫类继承动物类
public class Cat extends Animal {
//无参构造
public Cat() {}
//带参构造
public Cat(String name, int age) {
super(name, age);
}
//重写抽象方法
public void eat() {
System.out.println("猫吃鱼");
}
}
//定义一个狗类继承动物类
public Dog extends Animal {
//无参构造
public Dog() {};
//带参构造
public Dog(String name, int age) {
super(name,age);
}
//重写抽象方法
public void eat() {
System.out.println("够吃骨头");
}
}
//测试类
public class Test {
public static void main(String[] args) {
Animal cat = new Cat();
cat.setName("加菲");
cat.setAge(2);
//输出:加菲,2
System.out.println(cat.getName() + cat.getAge());
Animal dog = new Dog();
dog.setName("哈士奇");
dog.setAge(3);
//输出:哈士奇,3
System.out.println(dog.getName() + dog.getAge());
}
}
接口
接口概述:如果一个类中的全部方法都是抽象方法,全部属性都是全局常量,那么这个类可以定义为一个接口;
接口:使用关键字interface定义一个接口;
//定义一个接口Animal
public interface Animal {}
接口的成员特点
成员变量只能是常量;使用public static final修饰;
接口没有构造方法,因为接口主要是对行为进行抽象的,没有具体的存在;
一个类如果没有父类,默认继承自Object;
成员方法只能是抽象方法,默认使用public abstract修饰;
public interface Inter {
//成员变量
int num = 10;//简写的形式
public static final int num = 10;//接口里面的成员变量的默认修饰符public static final
//成员方法
void show();//抽象方法的简写形式
public abstract method();//抽象方法的完整写法
//接口的构造方法不存在
}
猫和狗的案例
//定义抽象动物类Animal
public abstract class Animal {
//成员变量
private int age;
private String name;
//set/get方法
public void setAge(int age) {
this.age = age;
}
public int getAge() {
reteurn age;
}
public setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//无参构造方法
public Animal() {}
//带参构造方法
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
//抽象方法eat()
public abstract eat();
//定义一个接口Jumpping
public interface Jumpping {
public abstract void eat();
}
//定义一个猫类继承Animal实现JumpImpl接口
public class Cat extends Animal implements Jumpping {
//重写抽象方法eat()
public void eat() {
System.out.println("猫吃鱼");
}
//重写抽象方法jump()
public void jump() {
System.out.println("猫可以跳高了");
}
}
//定义TestDemo类完成测试
public class TestDemo {
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("加菲猫");
cat.setAge(2);
//输出结果:加菲猫,2岁
System.out.println(cat.getName() + "," + cat.getAge() + "岁");
//猫吃鱼
cat.eat();
//猫可以跳高了
eat.jump();
}
}
类和接口的关系
类和类的关系:继承关系,只能单继承,但是可以多层继承;
接口和接口的关系:继承关系,可以单继承,也可以多继承;
类和接口的关系:实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口;
抽象类和接口的关系
成员区别:
抽象类:成员变量有变量和常量;也有构造方法;有抽象方法和非抽象方法;
接口:成员变量只能是常量;没有构造方法;只有抽象方法;
关系区别:
类和类:继承,只能单继承;
类和接口:实现,可以单实现,也可以多实现;
接口与接口:继承,单继承,多继承;
设计理念区别:
抽象类:对类抽象,包括属性和行为;
接口:对行为抽象,主要是行为;
运动员和教练的案例
1.定义说英语接口;成员方法:说英语();
2.定义抽象人类;成员变量:name,age;构造方法:无参,带参;成员方法:set/get方法,吃饭();
3.定义抽象教练类,抽象运动员类;
5.定义具体的篮球教练类,继承教练类;
6。定义具体的乒乓球教练类,继承教练类;
7.定义具体的篮球运动员类,继承运动员类;
8.定义具体的乒乓球运动员类,继承运动员类;
//定义说英语的接口
public interface English {
public abstract void speakEnglish();
}
//定义抽象人类
public class Person {
private int age;
private String name;
public Person() {}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void setName() {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public abstract void eat();
}
//定义一个抽象教练类
public abstract class Coach extends Person {
public Coach() {}
public Coach(String name, int age) {
super(name,age);
}
public abstract void teach();
}
//抽象运动员类
public abstrach class Palyer extends Person {
public Player() {}
public Player() {
super(name,age);
}
public abstract void study();
}
//定义具体的篮球教练类
public class BasketballCoach extends Coach {
public BacketballCoach() {}
public BacketballCoach(String name,int age) {
super(name,age);
}
//重写teach方法
public void teach() {
System.out.println();
}
//重写eat方法
public void eat() {
System.out.println();
}
}
//定义具体的乒乓球教练类
public class PingPangCoach extends Coach implements English {
public PingPangCoach() {}
public PingPangCoach(String name,int age) {
super(name,age);
}
public void teach() {
System.out.println();
}
public void eat() {
System.out.println();
}
public void speakEnglish() {
System.out.println("说好英语");
}
}
//定义具体的篮球运动员类
public class BacketballPlayer extends Player {
public BacketballPlayer() {}
public BacketballPlayer(String name,int age) {
super(name,age);
}
public void study() {
System.out.println("篮球运动员学习如何运球和投球");
}
public void eat() {
System.out.println("吃好喝好");
}
}
//定义具体的乒乓球运动员类
public class PingPangPlayer extends Player implements SpeakEnglish {
public PingPangPlayer() {}
public PingPangPlayer(String name,int age) {
super(name,age);
}
public void study() {
System.out.println("乒乓球运动员学习如何发球和运球");
}
public void eat() {
System.out.println("牛肉火锅");
}
public void speakEnglish() {
System.out.println("说好英语");
}
}
//main()测试
public static main(String[] args) {
PingPangPlayer pingpang = new PingPangPlayer();
pingPang.setName("王林");
pingPang.setAge(25);
pingPang.study();
pingPang.eat();
pingPang.speakEnglish();
}