抽象类和接口

1.抽象类

1.1什么是抽象类

一个类中如果有抽象方法，那么该类一定是抽象类；抽象类不一定存在抽象方法。

抽象类和抽象方法必须要用关键字：abstract（抽象的）修饰

注：abstract关键字不能和那些关键字一块使用

final   、private   、 static...

1.2没有抽象方法的抽象类有什么作用

一个类中没有抽象方法,那么这个类可以不可以定义为抽象类?意义是什么?

可以,不能让当前类直接进行实例化,需要通过一些静态功能来间接实例化!

1.3抽象类的格式

//抽象类
public abstract class 类名{

    //抽象方法
    public abstract void 方法名（）;
}

 1.4抽象类的特点

1）抽象类不能实例化

抽象类如何实例化？

按照多态的方式，由具体的子类实例化。称为：抽象类的多态

//抽象类
class abstract Animal{
    //抽象方法
    public abstract void eat();  
}
//抽象类的子类
class Dog extends Animal{  //extends :继承自...
    //必须重写抽象类中的抽象方法
    public void eat(){
        System.out.println("狗吃骨头...");
    }
}

//测试类
class Test{

    public static void mian(String args[]){
        //抽象类的多态
        Animal a = new Dog();
    }

}

2）抽象类的成员特点

2.1）成员变量：可以是变量，也可以是常量

2.2）构造方法：有构造方法，但不能实例化，用于子类访问父类数据的初始化

3.3）成员方法：可以是抽象方法：限定子类必须完成某些功能  也可以是非抽象方法。

1.5练习

//测试类
public class Test {
	public static void main(String[] args) {
		
		//测试狗
		//抽象类多态
		Animal a = new Dog() ;//向上转型
		a.setName("小白");
		a.setAge(3);
		a.setColor("白色");
		System.out.println(a.getName()+"---"+a.getAge()+"---"+a.getColor());
		a.eat();
		a.sleep();
		//a.playGame() ;
		
		//向下转型
		Dog d = (Dog)a;
		d.playGame();
		System.out.println("--------------------------");
		
		//抽象类多态:
		Animal a2 = new Dog("小白2",5,"白色") ;//向上转型
		System.out.println(a2.getName()+"---"+a2.getAge()+"---"+a2.getColor());
		a2.eat();
		a2.sleep();
		Dog dd = (Dog)a2;
		dd.playGame();
	}
}


//抽象的动物类
abstract class Animal {

	//属性私有化
	private String name ;
	private int age ;
	private String color ;
	
	public Animal() {
		super();
	}
	//有参构造方法
	public Animal(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	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 getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	//吃和睡 的动作给出一个声明
	public abstract void eat() ;
	public abstract void sleep() ;
	
	
	
	
}

//猫类
class Cat extends Animal {

	
	
	public Cat() {
		super();
	}

	public Cat(String name, int age, String color) {
		super(name, age, color);
	}

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}

	@Override
	public void sleep() {
		System.out.println("猫趴着睡觉...");
	}
	
	public void catchMouse() {
		System.out.println("猫抓老鼠...");
	}

}
//狗类
class Dog extends Animal {

	
	public Dog() {
		super();
	}

	public Dog(String name, int age, String color) {
		super(name, age, color);
	}

	@Override
	public void eat() {
		System.out.println("狗吃骨头...");
	}

	@Override
	public void sleep() {
		System.out.println("狗侧睡...");
	}
	public void playGame() {
		System.out.println("狗可以玩猫...");
	}

}

                         

2.接口

2.1什么是接口

Java中的一些额外功能，并不给出具体实现，将包含这些额外功能的称为接口

2.2接口的特点

接口用关键字interface 表示

接口的格式和实例化

interface Inter{
    //接口中只能定义抽象方法
    void jump();  //接口中的抽象方法隐藏了 public abstract  等修饰符
}

class Dog implenents Inter{
    
    //必须重写接口中的方法
    public void jump(){
        System.out.println("狗经过训练学会跳了...");
    }
} 

//测试了
public class Test{
    public static void main(String args[]){
        Dog d = new Dog();
        d.jump();
    }

}

 接口不能实例化，如何实例化接口

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

2.3接口成员特点

1）成员变量：这能是常量：有默认修饰符：public static final

2）构造方法：没有构造方法，因为接口主要是扩展功能的，而没有具体存在

3）成员方法：只能是抽象方法 ：默认修饰符：public abstract

3.抽象类与接口的比较

3.1类与类，类与接口，接口与接口的关系

1）类与类：继承关系只能单继承，但是可以多层继承

2）类与接口：可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

3）接口与接口：可以单继承关系，也可以多继承

3.2抽象类和接口的区别

1）成员区别

抽象类：变量，常量；可以有抽象方法，构造方法，非抽象方法

接口：常量，抽象方法

2）关系区别

 类与类 继承，单继承

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

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

3）设计理念区别

抽象类：被继承体现的是一种“is a ”的关系

接口：被实现体现的是：“like a ”的关系。