JAVA基础13----抽象类,接口

1./面向对象抽象类/
/*
抽象类的特点:
A.抽象类和抽象方法必须用abstract关键字修饰
abstract class 类名 {}
public abstract void 方法名();
B.抽象类不一定有抽象方法,有抽象方法的类一定是抽象类或者接口
C.抽象类不能实例化,那么抽象类如何实现实例化那?
按照多态的方式,由具体的子类实例化,其实这也是多态的一种,抽象类多态
D.抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
*/

class Demo1_Abstract {
	public static void main(String[] args) {
		//Animal an = new Animal();//Demo1_SuperMan.java:16: 错误: Animal是抽象的; 无法实例化
		Animal a = new Cat();      //父类引用指向子类对象
		a.eat();
	}
}
abstract class Animal {             //抽象类
	public abstract void eat();     //抽象方法
}

abstract class Cat extends Animal {  //Demo1_Abstract.java:17: 错误: Cat是抽象的; 无法实例化
	/*public void eat() {
			System.out.println("猫吃鱼");
		}*/
	
}

2./面向对象抽象类/
/*A.抽象类的成员特点
a.成员变量:
既可以是变量,也可以是常量,abstract不能修饰成员变量
b.构造方法:
用于子类访问父类数据的初始化
c.成员方法:
既可以是抽象的,也可以是非抽象的 .
d.抽象类的成员方法特性
1.抽象方法 强制要求子类做的事情
2.非抽象方法 子类继承的事情,提高代码的复用性
*/
class Demo2_Abstract {
public static void main(String[] args) {
System.out.println(“Hello World!”);
}
}

abstract class Demo {
	int num = 10;
	final int NUM = 20;
	public Demo () { }

	public void print() {
		System.out.println("print");
	}

	abstract public void method();
}

class Demo1 extends Demo {          //Demo2_Abstract.java:32: 错误: Demo1不是抽象的, 并且未覆盖Demo中的抽象方法method()
	public void method() {
		System.out.println("method方法重写");
	}
}

3.抽象练习

class Demo_AnimalAbstract {
	public static void main(String[] args) {
		Animal c = new Cat();
		c.setName("小猫猫");
		System.out.println(c.getName());
	}
}

abstract class Animal {
	private String name;
	private int age;
	
	public Animal(){}

	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		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();
}

class Cat extends Animal {
	public Cat(){}
	public Cat(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("猫吃鱼");
	}
	public void zhua(){
		System.out.println("猫抓老鼠");
	}
	
}

class Dog extends Animal {
	public Dog(){}
	public Dog(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("狗吃肉");
	}

	public void lookHome() {
		System.out.println("狗看家");
	}
}

class Demo3_Abstract {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}
//abstract 不能和那些关键字共存
abstract class Demo {
	//public static abstract void print();          
	// 错误: 非法的修饰符组合: abstract和static
    //被abstract 修饰的方法没有方法体,被static修饰的可以用类名.调用,但是类名.调用抽象没有意义
	//public final abstract void print();          
	// 错误: 非法的修饰符组合: abstract和final
	//被abstract修饰的方法强制子类重写
	//final修饰的不让子类重写
	//private abstract void print ();
	//被abstract修饰的是为了让子类看到并强制抽象
	//被private修饰不让子类访问,所以他们两个是矛盾的
}

5./接口interface/
/*
A.接口概述:
从狭义的角度讲就是指的java中的interface,接口中的方法都是抽象方法
从广义的角度讲就是对外提供规则的都是接口
B.接口特点:
1.接口用interface关键字表示
interface 接口名 {}
2.类实现接口用implements表示
class 类名 implements 接口名 {}
3.接口不能实例化
那么,如何实现实例化那?按照多态的方式实现实例化
4.接口的子类
a.可以是抽象类,但是意义不大
b.可以是具体类,要重写接口中的所有抽象方法(推荐)
*/

class Demo1_Interface {
	public static void main(String[] args) {
		//Inter i = new Inter();  //错误: Inter是抽象的; 无法实例化
		//Demo d = new Demo();
		Inter d = new Demo();     //父类引用指向子类对象
		d.print();
	}
}

interface Inter {
	public abstract void print();
}
class Demo implements Inter {
	public void print() {
		System.out.println("Demo print");
	}
}

6./interface/
/*
成员变量:只能是常量,并且是静态的公共的.
默认修饰符:public static final
构造方法:接口没有构造方法
成员方法:只能是抽象方法.
默认修饰符:public abstract

*/

class Demo2_Interface {
	public static void main(String[] args) {
		System.out.println(Inter.num1);
	}
}
interface Inter {
	public static final int NUM = 10;
	int num1 = 20;

	public abstract void print ();
}

class demo /*extends object*/implements Inter {   //一个类不写继承任何类,默认继承object类
	public void print() {
		System.out.println(NUM);
	}
}

7./类与类,类与接口,接口与接口的关系/
/*
A.类与类:
继承关系,只能单继承,可以多层继承
B.类与接口
实现关系,可以单实现,也可以多实现
并且还可以在继承一个类的同时实现多个接口
C.接口与接口
继承关系,可以单继承,也可以多继承
*/

class Demo2_Interface {
	public static void main(String[] args) {
		
	}
}

interface InterA {
	public abstract void printA();
}
interface InterB {
	public abstract void printB();
}
interface InterC extends InterA,InterB{
}
class Demo implements InterA,InterB {
	public void printA(){
		System.out.println("printA");
	}
	public void printB(){
		System.out.println("printB");
	}
}