Java -- 面向对象【接口】

「爱情、让人受尽委屈。」 2023-07-25 09:25 67阅读 0赞

*  Java接口是Java语言中存在的结构，有特定的语法和结构，Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。接口实现和类继承的规则不同，因为Java接口不涉及表象，因此Java接口本身没有任何实现；
 *  接口把方法的特征和方法的实现分割开来。这种分割体现在接口常常代表一个角色，它包装与该角色相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。一个角色由不同的演员来演，而不同的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]

##### 1、概念 #####

*  Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现；
 *  Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现；
 *  OOP面向对象的编程，如果要**提高程序的复用率，增加程序的可维护性，可扩展性**，就必须是**面向接口的编程**，面向抽象的编 程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

##### 2、特点 #####

1.  接口中都是抽象方法；
2.  通过`interface`关键字创建接口；
3.  通过`implements`让子类来实现；
4.  可以理解成，接口是一个特殊的抽象类；
5.  接口突破了java的单继承的局限性；
6.  接口和类之间可以**多实现**，接口和接口之间可以**多继承**；
7.  接口是**对外暴露**的规则，是一套开发规范；
8.  接口提高了程序的功能扩展，**降低了耦合性**

##### 3、入门案例 #####

package cn.tedu.interfacedemo;
    
    //这个类用来测试接口 -- 入门案例
    public class Test_Interface { 
    	public static void main(String[] args) { 
    		Inter inter = new InterImpl();
    		inter.save();
    		inter.update();
    	}
    }
    
    //1、定义接口
    interface Inter{ 
    	//2、接口是一个特殊的抽象类，特殊在哪？ -- 特殊在接口里都是抽象方法
    	abstract public void save();
    	abstract public void update();
    }
    
    //创建子类，使用接口的功能
    //3、通过implements，使用接口的功能
    //4、接口是一个特殊的抽象类，接口实现类的用法和继承时的子类的用法一样？还是2条路
    // -- 实现类还是两条路，要么是抽象的实现类，要么重写所以抽象方法
    //方法 ① 
    //abstract class InterImpl implements Inter{ 
    // 
    //}
    
    //方法 ② 
    class InterImpl implements Inter{ 
    	@Override
    	public void save() { 
    		// TODO Auto-generated method stub
    		System.out.println("保存");
    	}
    	@Override
    	public void update() { 
    		// TODO Auto-generated method stub
    		System.out.println("更新");
    	}
    }

![在这里插入图片描述][20200414103205951.png]

##### 4、接口的用法 #####

package cn.tedu.interfacedemo;
    
    //测试接口的使用
    public class Test_UseInterface { 
    	public static void main(String[] args) { 
    		Inter1 in = new Inter1Impl();
    		
    		//不允许修改值
    		//in.age = 2;//The final field Inter1.age cannot be assigned
    // System.out.println(in.age);
    		System.out.println(Inter1.age);
    		
    		in.del();
    	}
    }
    interface Inter1{ 
    	//1、接口中不可以存在构造方法
    // public Inter1() {}
    	
    	//2、接口里的成员变量？？ -- 没有！！！接口里都是静态的常量，会为变量自动拼接 public static final
    	//public static final int age = 30;//全拼
    	int age = 30;//简写
    	
    	//3、接口里的成员方法？？ -- 不能是普通方法！！都是抽象方法
    	//public static void del();
    	//会为方法自动拼接 public static
    	void del();//简写
    }
    
    class Inter1Impl implements Inter1{ 
    	@Override
    	public void del() { 
    		// TODO Auto-generated method stub
    		System.out.println("删除");
    	}
    }

![在这里插入图片描述][20200414103247315.png]

##### 5、接口的复杂用法 #####

Java中单继承的局限性通过接口可以解决。  
接口可以多继承也可以多实现，甚至可以继承的同时多实现。

*  多实现：是指实现类和接口的关系，实现类可以同时使用多个接口

package cn.tedu.interfacedemo;
    
    //这个类用来测试接口的复杂用法，多实现：是指实现类和接口的关系，实现类可以同时使用多个接口
    public class Test_ManyExtendsImpl { 
    	public static void main(String[] args) { 
    		
    	}
    }
    //定义接口
    interface Inter_I{ 
    	void save();
    	void delete();
    }
    interface Inter_II{ 
    	void get();
    }
    //创建实现类，同时使用1、2两个接口的功能,多个接口间逗号隔开，
    //实现类需要重写多个接口里的所有抽象方法，否则就是一个抽象的实现类
    //abstract class InterImpl implements Inter_I,Inter_II{ 
    class IntersImpl implements Inter_I,Inter_II{ 
    	@Override
    	public void get() { 
    		System.out.println("get()...");
    	}
    	@Override
    	public void save() { 
    		System.out.println("save()...");
    	}
    	@Override
    	public void delete() { 
    		System.out.println("delete()...");
    	}
    }

*  多继承：突破了java单继承的局限性，是指接口和接口间的关系

package cn.tedu.interfacedemo;
    
    //这个类用来测试 接口的 多继承：突破了java单继承的局限性，是指接口和接口间的关系
    public class Test2_ManyExtendsImpl { 
    	public static void main(String[] args) { 
    		
    	}
    }
    //创建父接口
    interface Inter_III{ 
    	void get();
    	void delete();
    }
    interface Inter_V{ 
    	void select();
    }
    //2、接口和接口间，可以发生继承关系，还可以多继承？
    	// -- 只需要逗号隔开
    //创建子接口
    interface InterIV extends Inter_III,Inter_V{ 
    	void update();
    	//1、此时，InterIV接口到底几个功能？？
    		//--- 3个，继承过来两个，自身有一个
    }
    //创建实现类
    class InterImpl2 implements InterIV{ 
    	@Override
    	public void get() { 
    		System.out.println("get()...");
    	}
    	@Override
    	public void delete() { 
    		System.out.println("delete()...");
    	}
    	@Override
    	public void update() { 
    		System.out.println("update()...");
    	}
    	@Override
    	public void select() { 
    		System.out.println("selete()...");
    	}
    }

*  单继承的同时多实现 ------ 针对实现类而言

package cn.tedu.interfacedemo;
    
    //这个类用来测试 实现类 可以 单继承的同时多实现
    public class Test3_ManyExtendsImpl { 
    	public static void main(String[] args) { 
    		Inter6 inter6 = new Zi();
    		inter6.save();
    	}
    }
    interface Inter6{ 
    	void save();
    }
    interface Inter7{ 
    	void delete();
    }
    //把父类设置成抽象类
    abstract class Fu{ 
    	abstract public void eat();
    	public void get() { 
    		System.out.println("get()....");
    	}
    }
    //作为实现类，可以单继承的同时多实现
    class Zi extends Fu implements Inter6,Inter7{ 
    	@Override
    	public void delete() { 
    		System.out.println("delete()...");
    	}
    	@Override
    	public void save() { 
    		System.out.println("save()...");
    	}
    	@Override
    	public void eat() { 
    		System.out.println("eat()...");
    	}
    }

##### 6、总结（尝试自己总结） #####

1.  类和类的关系：**继承，而且是单继承**  
    – `class Zi extends Fu`  
    – Zi是子类 单继承 Fu是父类；  
    – 让子类继承父类，子类就拥有了父类的所有功能(除了private)；  
    – 方法重写`@override`，要求是子类的方法声明和父类一样，改的是方法体；  
    – super关键字可以在子类中使用，用来调用父类的功能，代表的是父类对象的引用；
2.  接口和接口的关系：**继承，而且可以多继承(逗号隔开)**  
    – `interface Inter1 extends Inter2`  
    – 其中，Inter1子接口 ， inter2父接口，此时Inter1拥有inter2的所有功能；  
    – `interface inter3 extends Inter2 , Inter1`  
    – 其中，inter3也是接口，可以同时使用Inter2 和 Inter1 的功能；  
    – 为了突破java单继承的局限性而来；
3.  实现类和接口之间的关系：**实现，而且可以多实现(逗号隔开)**  
    – `class InterImpl implements Inter1`  
    – 其中，InterImpl是实现类，Inter1是接口；  
    – 此时，InterImpl拥有接口里的所有功能，并且需要重写所有抽象方法，否则就是抽象类；  
    – `class InterImpl implements Inter1 , Inter2`  
    – 其中，InterImpl实现了Inter1和Inter2的所有功能，重写所有抽象方法，否则还是抽象类；  
    – `class InterImpl extends Fu implements Inter1 , Inter2`  
    – 其中，InterImpl继承了Fu类的功能，同时拥有了Inter1和Inter2的所有功能；  
    – 要求InterImpl重写所有抽象方法，否则就是抽象类；
4.  接口和抽象类的区别：  
    – 抽象类是一个特殊的类，特殊在抽象类中可以有普通方法和抽象方法  
    – 接口是一个特殊的抽象类，**特殊在接口里都是抽象方法**  
    – 语法上的区别：  
    （1）接口里没有构造方法，抽象类里有  
    （2）接口里没有变量，抽象类里有  
    （3）接口里的常量和方法都可以简写，抽象类不能简写  
    （4）接口和实现类是实现关系，抽象类和子类是继承关系  
    （5）定义接口和定义抽象类用的关键字不同
5.  abstract注意事项：  
    **抽象方法要求子类继承后必须重写；** 那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。  
    （1）private：被私有化后，子类无法重写，与abstract相违背。  
    （2）static：静态的，优先于对象存在。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。  
    （3）final：被final修饰后，无法重写，与abstract相违背。

**【前情回顾】**

上篇文章介绍了抽象类，加上本文的接口，但是细心地你肯定会发现，现在的内容都是前面的基础组合起来的内容，没有涉及很多的知识盲区，所以突出了基础知识掌握牢固的重要性！！！！学好编程一定不要懒，手要动起来，不要只是臆想，白日做梦并不是明智之举，一定要动手，找到自己的知识盲区，找到自己的学习方法，尝试用一种自己的方法记录自己的学习收货。

加油 ~

**【练习案例】**

*  具体事物：大神班级，小白班级
 *  共性：姓名，学号，学习方法，休假方法
 *  利用面向抽象 、 面向接口的编程思想，完成程序设计。
 *  要求：
 *  （1）利用两种方法编写
 *  （2）理解两种方法的异同
 *  开发思路：
 *  （1）先提取共性，形成父类；
 *  （2）把父类当做抽象层，利用面向抽象，面向接口的思想完成设计；
 *  （3）把父类可以修饰成抽象类或者接口

![在这里插入图片描述][20200414192521393.gif_pic_center]  
**【下篇预告】**

*  API：Application Programming Interface应用编程接口，一切可以调用的东西都是API。

**【练习案例答案】**

*  abstract ---- 抽象类

package cn.tedu.test.Homework;
    
    public class Abstract_Homework { 
    	public static void main(String[] args) { 
    		//创建对象
    		Tedu t = new PeiYouStudent();
    		t.rest();
    		t.study();
    		Tedu t2 = new GaoShouStudent();
    		t2.study();
    		t2.rest();
    	}
    }
    //抽象类
    abstract class Tedu{ 
    	//共性学习和休息
    	public abstract void study(); 
    	public abstract void rest(); 
    }
    
    class PeiYouStudent extends Tedu{ 
    	@Override
    	public void study() { 
    		System.out.println("我欲成仙，法力无边");
    	}
    	@Override
    	public void rest() { 
    		System.out.println("活着干，死了算");
    	}
    }
    class GaoShouStudent extends Tedu{ 
    	@Override
    	public void study() { 
    		System.out.println("玩什么飞机大战");
    	}
    	@Override
    	public void rest() { 
    		System.out.println("一切为了money");
    	}
    }

*  interface ---- 接口

package cn.tedu.test.Homework;
    
    public class Interface_Homework { 
    	public static void main(String[] args) { 
    		//创建对象测试
    		TeduTest tedu = new TeduPeiYouImpl();
    		tedu.rest();
    		tedu.study();
    		TeduTest tedu2 = new TeduGaoShouImpl();
    		tedu2.rest();
    		tedu2.study();
    	}
    }
    //创建接口
    interface TeduTest { 
    	//学习和休息方法
    	void study();
    	void rest();
    }
    
    //大神班级
    class TeduPeiYouImpl implements TeduTest{ 
    	@Override
    	public void study() { 
    		System.out.println("大神班级正在学习接口");
    	}
    	@Override
    	public void rest() { 
    		System.out.println("大神班级不需要休息");
    	}
    }
    //小白班级
    class TeduGaoShouImpl implements TeduTest{ 
    	@Override
    	public void study() { 
    		System.out.println("小白班级好好练习你们的飞机大战");
    	}
    	@Override
    	public void rest() { 
    		System.out.println("小白班级的！！什么时候了还休息，熄灯睡觉");
    	}
    }

**【知识拓展】**

**了解软件设计的开闭原则OCP**

*  开放功能扩展，关闭源码修改等；
 *  开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统；
 *  开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的；
 *  开闭原则，是一种设计模式，随着面向对象程序设计的思想，应运而生；
 *  开，指的是可以在源代码的基础上进行扩展，比如继承，接口，抽象类等。在JAVA中，之所以用继承，是在可以直接调用类库的前提下，对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发；
 *  闭：指不允许对原有的代码进行修改。以免影响其他现有功能，造成功能瘫痪。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]  
会编程没什么可豪横的 ~~~~

加油铁汁们 ~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/c03f406c07b8444c9963f5499a1bda27.png
[20200414103205951.png]: /images/20230528/3a3b41e8287f49be9e2893542feaf310.png
[20200414103247315.png]: /images/20230528/e21f3c6a44c74c498c02aa95e66ae872.png
[20200414192521393.gif_pic_center]: /images/20230528/c1c03a738a114b34976ae3bccf0bdd6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230528/0422273c0c70447a852e495368ec6f79.png