JAVA基础课程(第十三天)

JAVA基础课程

第十三天

抽象类与抽象方法

​ （1）abstract：抽象的

​ （2）可以修饰类，方法

​ （3）修饰类：

​ ①此类不能实例化

​ ②抽象类一定有构造器，便于子类实例化调用（涉及：子类对象实例化全过程）

​ ③开发中都会提供抽象类的子类，让子类对象实例化，完成相关操作

​ （4）修饰方法：

​ ①抽象方法只有方法声明，没有方法体

​ ②包含抽象方法的类，一定是一个抽象类，反之抽象类中可以没有抽象方法的。

​ ③若子类重写父类中的所有抽象方法之后，则子类方可实例化

​ 若子类没有重写父类的所有抽象方法，则子类也是一个抽象类。需要abstract修饰

​ （5）abstract需要注意的点

​ ①abstract不能修饰属性和构造器等结果

​ ②abstract不能修饰私有方法。静态方法。final的方法。final的类

​ 如果定义成私有方法，静态方法，final的方法。final的类那就不能重写了。就违背了abstract的设计理念

​ （6）代码示例：

package com.test.course.abstracttest;

/**
 * @author PitterWang
 * @create 2020/4/30
 * @since 1.0.0
 */
public abstract class Persion {
	public Persion(){
		System.out.println("Persion");
	}
	public abstract void eat();
	public void run(){
		System.out.println("run-------------");
	}
}

class Work extends Persion{
	public Work(){
		System.out.println("Work");
	}
	@Override
	public void eat() {
		System.out.println("工人吃饭");
	}
	@Override
	public void run(){
		System.out.println("工人run------");
	}
}

class Teacher extends Persion{
	public Teacher(){
		System.out.println("Teacher");
	}
	@Override
	public void eat() {
		System.out.println("老师吃饭");
	}
}
/***
 * 若子类没有重写父类的所有抽象方法，则子类也是一个抽象类。需要abstract修饰
 */
abstract class IT extends Persion{

}

抽象类的匿名子类

public class PersionTest {

	public static void main(String[] args) {
		/***
		 * Persion p = new Persion(); 报错，抽象类不能实例化
		 */
		Persion persion = new Teacher();
		persion.run();
		System.out.println("1~~~~~~~~~~~~~~~~~~~~~~~~");
		Persion work = new Work();
		work.run();
		System.out.println("2~~~~~~~~~~~~~~~~~~~~~~~~");
		/***
		 * 非匿名类的匿名对象
		 */
		method(new Work());
		System.out.println("3~~~~~~~~~~~~~~~~~~~~~~~~");
		/***
		 * 创建匿名子类的对象p
		 */
		Persion p = new Persion() {
			@Override
			public void eat() {
				System.out.println("匿名类eat~~~");
			}
		};
		/***
		 * 父类的方法
		 */
		p.run();
		/***
		 * 子类的方法
		 */
		p.eat();
	}

	public static void method(Persion persion){
		persion.run();
		persion.eat();
	}
}

接口

​ （1）interface：接口

​ （2）接口和类并列未两种结构

​ （3）如何定义接口：定义接口中的成员

​ ①JDK7及以前：只能定义全局常量和抽象方法

​ ②JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法，默认方法

​ 1.接口中定义的静态方法，只能通过接口来调用

​ 2.通过实现类的对象，可以调用接口中的默认方法，如果实现类重写了接口中的默认方法，调用时，仍然 可以调用重写后的方法

​ 3.如果子类继承了父类并且实现了接口中同名同参数的方法，若子类没有调重写重复的方法，默认调用父 类的同名同参数方法

​ 4.如果实现的多个接口中都定义了同名同方法的默认方法，实现类没有重写会报错–接口冲突

​ 5.在子类中调用父类或者接口中重写的方法

​ super.方法名（）调用父类的方法

​ 接口名.super.方法名（）调用接口中的默认方法

​ （4）接口不能定义构造器，意味着不能实例化

​ （5）Java开发中，接口通过让类去实现（implement）的方式去使用。

​ 如果实现类实现了接口的全部抽象方法，则次实现类可以实例化

​ 如果实现类没有覆盖接口中的所有抽象方法，则实现类仍为一个抽象类

​ （6）Java中可以实现多个接口，弥补Java当继承性的局限性

​ 格式：class A extends B implement C,D,E

​ （7）接口与接口之间可以继承，并且可以实现多继承

​ （8）代码实现

​

package com.test.course.interfacetest;

public interface Usb {

	public static final int MAX_SPEED = 10;

	/**
	 * public abstract 可以不写
	 */
	void star();
	public abstract void stop();
}

class Computer{
	private Usb usb;
	public Computer(Usb usb){
		this.usb = usb;
	}
	public void insert(){
		this.usb.star();

		this.usb.stop();
	}
}
class Upen implements Usb{

	@Override
	public void star() {
		System.out.println("Upen 启动");
	}

	@Override
	public void stop() {
		System.out.println("Upen 停止工作");

	}
}

class Phone implements Usb{

	@Override
	public void star() {
		System.out.println("Phone 启动");

	}

	@Override
	public void stop() {
		System.out.println("Phone 启动");
	}
}


interface AA{
	void mothod();
	default void a(){
		System.out.println("AA的a方法");
	}
}
interface BB{
	void mothod();
	default void a(){
		System.out.println("BB的a方法");
	}
}
abstract class CC{
	abstract void mothod();

	void a(){
		System.out.println("CC的a方法");
	}
}

class Test extends CC implements AA,BB{

	@Override
	public void mothod() {
		System.out.println("Test的Method的方法");
	}

	@Override
	public void a() {
		System.out.println("Test的a的方法");
	}


	public void run(){


		super.a();
		AA.super.a();
		BB.super.a();
	}
	public static void main(String[] args) {
		Test test = new Test();
		test.run();

	}
}