抽象类和接口

抽象类

抽象类：使用关键字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();
}