java基础之抽象类和接口

我会带着你远行 2022-07-14 14:39 215阅读 0赞

## java基础之抽象类和接口 ##

### 1、抽象类 ###

* 1、abstract 修饰类：抽象类
     * 1) 不可被实例化
     * 2）抽象类有构造器
     * 3）抽象方法所在的类一定是抽象类，但是抽象类可以没有抽象方法
     * 
     * 2、abstract 修饰方法：抽象方法
     * 1）格式：没有方法体，包括{}
     * 2）抽象方法只保留方法的功能，而具体的执行交给继承抽象类的子类，由子类重写此抽象方法。
     * 3）若子类继承抽象类，并重写了所有的方法，则此类是一个可以实例化的类；若子类继承抽象类，没有重写所有的抽象方法，则此类必须声明为抽象的。

/**
     * abstract 不能用来修饰属性、构造器、private、final、static
     * //因为构造器不能被重写，所以构造器不能重写
     * //因为方法被声明成abstract，此方法必须要被子类重写，而private 修饰的方法，子类无法重写。
     * //当方法被static和abstract共用时，当类在调用这个方法时，方法没有body内容，无法执行。
     */

### 2、接口 ###

/**
     * 接口（interface） :是与类并行的一个概念
     * 1、接口可以看成一个特殊的抽象类。是常量与抽象方法的集合。不能包含变量以及一般的方法.
     * 常量:默认都是public static final来修饰的，抽象方法:默认都是public abstract来修饰。
     * 2、接口是没有构造器的。
     * 3、接口定义的就是一种功能，这个功能可以被类所实现。
     * 4、实现接口类，必须要重写其中所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类。
     * 5、类可以实现多个接口，-----java中继承是单继承的。
     * 6、接口与接口之间也是继承关系，类与接口之间关系是实现，类跟类之间是继承。
     * 7、接口之间的继承可以使多重继承。（这点与类不同）
     */

（1）接口多态性

public class TestInterface {
    		//接口多态性
    	public static void main(String[] args) {
    		Duck duck = new Duck();
    		test1(duck);
    		test2(duck);
    		test3(duck);
    	}
    	public static void test1(Runner r){//Runner r = new Duck();
    		r.run();
    	}	
    	public static void test2(Swimmer s){//Swimmer s= new Duck();
    		s.swim();
    	}	
    	public static void test3(Flier f){//Flier f= new Duck();
    			f.fly();
    		}
    	}
    	interface Runner{
    		public abstract void run();	
    	}
    	interface Swimmer{
    		void swim();
    	}
    	interface Flier{
    		void fly();
    	}
    	class Duck implements Runner,Swimmer,Flier{
    		@Override
    		public void fly() {
    			System.out.println("起飞");
    	}
    	@Override
    	public void swim() {
    		System.out.println("游泳");
    	}
    	@Override
    	public void run() {
    		System.out.println("跑步");
    		}	
    	}

（2）接口代理：（静态代理）

public class TestProxy {
    	public static void main(String[] args) {
    		Object object = new ProxyObject();
    		object.action();
    	}
    }
    interface Object{
    	void action();
    }
    class ProxyObject implements Object{
    	Object obj;
    	public ProxyObject(){
    		System.out.println("代理类创建成功");
    		obj = new ObjectImpl();
    	}
    	@Override
    	public void action() {
    		System.out.println("代理类开始执行");
    		obj.action();
    		System.out.println("代理类结束执行");
    	}
    }
    class ObjectImpl implements Object{
    	@Override
    	public void action() {
    		System.out.println("被代理类开始执行");
    		System.out.println("具体操作");
    		System.out.println("被代理类结束执行");
    	}
    }