java学习（8）类的四大特性2之继承（接口）

清疚 2021-06-24 15:58 379阅读 0赞

\* @笔记  
 \* 一、定义  
 \*    接口就是一些没有内容的方法，封装到一起，到某个要使用的时候，再根据具体情况把这些方法写出来。  
 \* 二、语法  
 \*    class 类名 implements 接口\{  
 \*        方法：  
 \*        变量：  
 \*    \}  
 \* 三、注意：  
 \*    1.接口不能实例化。  即：Usb usb1 = new Usb();是错的。  
 \*    2.接口中的方法不能有主体。即接口中所有方法都不能实现。而抽象类只有前面加abstract修饰符的方法不能有主体。  
 \*    3.一个类可以实现多个接口。  
 \*    4.接口可以使用变量，但是不可用private和protected修饰。  
 \*    5.接口中的变量，基本上都是static的，而且是final ， 不管你加不加static修饰  
 \*    6.在java开发中，我们常把经常用的变量，定义在接口中，作为全局变量使用。访问形式为：接口名。变量名。  
 \*    一个接口不能承接其他的类，但是可以承接别的接口。  
 \*  
 \* 四、小结  
 \*    1.接口是更加抽象的抽象类。  
 \*    2.接口体现了程序设计的多态性和高内聚低耦合的设计思想。  
 \*      
 \* 五、更加完善的类的方法。  
 \*    package 包名;  
 \*    class 类名 extends 父类 implements 接口名\{  
 \*        成员变量：  
 \*        构造方法：  
 \*        成员方法：  
 \*    \}  
 \*    因为java中类只允许单继承，比如一个鹦鹉会飞，会继承自鹦鹉类。如果他想像人一样说话，但是他已经继承了鹦鹉类，所以就不能再继承类了。  
 \*    所以可以通过调用接口的方式来进行调用。  
 \* 六、实现接口 VS 继承类  
 \*    java是单继承，即一个类最多有一个父类，这种单继承可以保证类的纯洁性，比C++中的多继承机制简洁，但对类功能的拓展有一定影响。  
 \*    所以我们认为：  
 \*    1.实现接口可以看做是对类的补充。  
 \*    2.继承是层级式的，不太灵活。例如：类2和类3继承类1，类4继承类2，类5继承类3。  
 \*      这种结构修改某个类的时候，就会打破这种平衡。而接口就没有这样的麻烦，它只针对实现接口的类才起作用。

\*      即：实现接口可以在不打破继承关系的前提下，对某个类功能拓展，非常灵活。

package com.shuiyixin;
    
    public class learnJ_8jiekou {
    
    	/**
    	 * @作者：shuiyixin
    	 * @日期：2018.01.31
    	 * @内容：接口
    	 * 
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Computer comp = new Computer();
    		Camera cam = new Camera();
    		comp.useUsb(cam);
    		
    		
    		SunWuKong Sun = new SunWuKong();
    		Sun.swim();
    		Sun.fly();
    		
    		
    		CarShop sc1 = new CarShop();
    		sc1.sellCar(new BWM());
    		System.out.println("卖出的总价为：" + sc1.getmoney());
    		sc1.sellCar(new CheryQQ());
    		System.out.println("卖出的总价为：" + sc1.getmoney());
    		
    	}
    }
    //定义USB接口
    interface Usb{
    	
    	int a = 1;
    	//声明两个方法
    	//开始工作
    	public void start();//接口中所有方法都不能实现。
    	//停止工作
    	public void stop();//接口中所有方法都不能实现。
    	
    }
    interface aaa{}
    //编写相机类，并实现USB接口
    //一个重要原则：当一个类实现了一个接口，就要求该类把这个接口的所有方法都实现。
    //一个类可以实现多个接口。
    class Camera implements Usb,aaa{
    	//开始工作
    	public void start(){
    		System.out.println("我是相机，我要开始工作了！！！");
    	}
    	//停止工作
    	public void stop(){
    		System.out.println("我是相机，我要停止工作了！！！");
    	}
    } 
    class Computer {
    	public void useUsb(Usb usb){
    		usb.start();
    		usb.stop();
    	}
    };
    class Monkey {
    	int name ;
    	public void jump(){
    		System.out.println("猴子会跳。");
    	}
    	
    }
    interface Fish8 {
    	//public void swim();接口的方法改变，不会影响调用接口的类的改变，降低了程序的错误率。
    }
    interface Bird {
    	public void fly();
    }
    //孙悟空是一个猴子，但是他可以上天入水
    class SunWuKong extends Monkey implements Fish8,Bird{
    	public SunWuKong(){
    		System.out.println("我是孙悟空。");
    	}
    	public void swim(){
    		System.out.println("我可以游泳");
    	}
    	public void fly(){
    		System.out.println("我可以飞");
    	}
    }
    
    //用接口实现多态
    interface Car {
    	//获取汽车的名称
    	String getName();
    	//获取汽车的价格
    	int getPrice();
    }
    //宝马
    class BWM implements Car{
    	public String getName(){
    		return "BWM";
    	}
    	public int getPrice(){
    		return 300000;
    	}
    }
    //奇瑞QQ
    class CheryQQ implements Car {
    	public String getName(){
    		return "CheryQQ";
    	}
    	public int getPrice(){
    		return 20000;
    	}
    }
    //汽车出售店
    class CarShop{
    	//售车收入
    	private int money = 0;
    	//卖出一部车
    	public void sellCar(Car car){
    		System.out.println("车型：" + car.getName() + "，单价为：" + car.getPrice());
    		//增加卖出车的收入
    		money += car.getPrice();
    	}
    	//售车总收入
    	public int getmoney(){
    		return money;
    	}
    }