本文接上文:java——面向对象详细介绍(二)

11、接口(interface)

引入:抽象类是从多个类中抽象出来的模板,若要将这种抽象进行得更彻底,就得用到一种特殊的“抽象类”→ 接口;

例子:

生活中听说过的USB接口其实并不是我们所看到的那些插槽,而是那些插槽所遵循的一种规范;而我们看到的那些插槽是根据USB规范设计出来的实例而已,也就说插槽是USB的实例;

对应不同型号的USB设备而言,他们各自的USB插槽都需要遵循一个规范,遵守这个规范就可以保证插入插槽的设备能与主板正常通信;

对于同一种型号的主板上的多个USB插槽,他们有相同的数据交换方式,相同的实现细节,可认为他们都是同一个类的不同实例

我的总结:

接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.

接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;

使用接口的好处,拓展性,维护性更好,所以我们在开发中会经常用到接口.(相当于定义了一种标准)

interface定义

接口定义一种规范,规定一个类必须做什么,但它不管如何具体去做;

[修饰符] interface 接口名 extends 父接口1,父接口2....

没有构造方法,不能实例化;

接口只能继承接口,不能继承类

接口里没有普通方法,方法全是抽象的;

接口里的方法默认修饰符是public abstract;

接口里的字段全是全局常量,默认修饰符是public static final;

接口里的成员包括(主要是前两个):

全局常量

公共的抽象方法

内部类(包括内部类,内部接口,内部枚举类);

我的总结:

接口没有构造方法,不能实例化!

接口里的方法全部是抽象的,没有普通方法,有默认的修饰符 public abstract,必须全部覆写!

12、接口的使用

格式:public class SubImpl extends Super implements IA,IB

接口可以多继承,但是只能继承接口,不能继承类。

实现接口(支持多实现)

[修饰符] class 类名 implements 接口1,接口2...

接口的实现必须在 extends 之后;

实现接口的方法必须是 public 类型

接口与类之间的关系:

实现关系或者说是继承关系.

可以说类实现了接口的方法,也可以说类继承了接口的方法,不同情况下不同的理解!

13、面向接口编程之制定标准和简单工厂模式

制定一个标准,让别人去实现或者说满足它!

Eg:
interface USB{//定义USB标准
    void useUSB();//USB有使用USB的行为
}

简单工厂模式

构建一个工厂出来,在里面进行生产,用的时候直接拿

我的总结:

好处:屏蔽不同子类实现的差异,提高代码的可拓展性和可维护性;

package reviewDemo;
 
//简单工厂模式
 
 
 
interface Phone{//制定标准,都要实现send()方法
 
   public void send();
 
}
 
 
 
class Iphone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("Iphone手机在发短信");
 
   }
 
}
 
 
 
class AndroidPhone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("AndroidPhone手机在发短信");
 
   }
 
}
 
 
 
class MyPhone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("MyPhone手机在发短信");
 
   }
 
}
 
 
 
class Factory{
 
   public static void show(String type){//传入参数,根据不同的类型个性化定制
 
      if(type.equals("")){//为空的情况,不用往下执行
 
         System.out.println("对不起,类型为空!,请重新输入!");
 
         return;
 
      }
 
      Phone p = null;
 
      if("Iphone".equals(type)){//判断类型
 
         p = new Iphone();
 
      }else if("AndroidPhone".equals(type)){
 
         p = new AndroidPhone();
 
      }else{
 
         p = new MyPhone();
 
      }
 
      p.send();
 
   }
 
}
 
 
 
public class FactoryDemo17 {
 
   public static void main(String[] args) {
 
     
 
      new Factory().show("Iphone");//调用方法
 
      new Factory().show("AndroidPhone");
 
      new Factory().show("MyPhone");
 
      new Factory().show("YourPhone");
 
      new Factory().show("");
 
   }
 
}

输出:

Iphone手机在发短信

AndroidPhone手机在发短信

MyPhone手机在发短信

MyPhone手机在发短信

对不起,类型为空!

14、面向接口编程之适配器模式

使用一个现成的类,但是它的接口不完全符合你的需求,我只想要它其中的一个方法,不想覆写其他的方法。

比如,窗体有变大,变小,关闭的行为,但是我现在只需要关闭行为;

package reviewDemo;
 
//适配器模式:只想用其中的某一个方法,用适配器作为中间的过渡
 
 
 
interface Windows{
 
   void max();
 
   void min();
 
   void close();
 
}
 
 
 
//适配器模式,实现接口所有的方法,但是不写方法体!
 
class AdapterWindows implements Windows{
 
 
 
   @Override
 
   public void max() {
 
   }
 
 
 
   @Override
 
   public void min() {
 
   }
 
 
 
   @Override
 
   public void close() {
 
   }
 
  
 
}
 
 
 
class MyWindows extends AdapterWindows{
 
   //覆写父类的方法
 
   public void close(){
 
      System.out.println("这个实现的是关闭功能!");
 
   }
 
}
 
 
 
public class Demo17 {
 
   public static void main(String[] args) {
 
      new MyWindows().close();
 
   }
 
}

接口和抽象类的比较

相同点:

都位于继承的顶端,用于被其他实现或继承;

都不能实例化;

都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;

一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

二者的选用:

优先选用接口,尽量少用抽象类;

需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

总结:接口不能有构造函数,抽象类是可以有构造函数的,

abstract可以定义构造函数(包括带函数的构造函数),因为要保证其子类在创建的时候能够进行正确的初始化,但是Abstract类不能被实例化。

知识点:如果不可以或者没有创建对象,那么我们必须加上static修饰,不能用对象调用,就只好用类去调用。

16、匿名内部类


适合只使用一次的类

不能是抽象类,因为系统在创建匿名内部类的时候,会立即创建匿名内部类的对象。

匿名内部类不能定义构造器,因为匿名内部类没有类名。

格式:
new 父类构造器([实参列表]) 或 接口()
{
//匿名内部类的类体部分
}

17、枚举类

使用enum声明,默认直接继承了java.lang.Enum类,而不是Object类;

枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。

枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。

枚举类的构造方法的权限修饰符默认是private;

一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;

所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象;

所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。

Eg:public enum Color{
 
        RED(), GREEN(){}, BLUE{};
 
}
 
 
 
 
 
package reviewDemo;
 
//枚举
 
 
 
enum Color{
 
   Green,Blue,Yellow;
 
  
 
   @Override
 
   public String toString() {
 
      String ret = super.toString();
 
      switch (this) {
 
      case Green:
 
         ret = "绿色";
 
         break;
 
        
 
      case Blue:
 
         ret = "蓝色";
 
         break;
 
        
 
      case Yellow:
 
         ret = "黄色";
 
         break;
 
 
 
      default:
 
         break;
 
      }
 
     
 
      return ret;
 
   }
 
  
 
}
 
 
 
class Personp{
 
   Color c = Color.Blue;
 
   void show(){
 
      System.out.println(c);
 
   }
 
}
 
 
 
public class Demo18 {
 
   public static void main(String[] args) {
 
      Color []color = Color.values();
 
      for (Color c : color) {
 
         System.out.println(c);
 
      }
 
      new Personp().show();
 
   }
 
}

输出:

绿色

蓝色

黄色

蓝色

枚举类覆写接口抽象方法的两种方式:

在枚举类中实现接口的抽象方法;

在枚举匿名内部类中实现接口的抽象方法;

interface I{
 
    void show();
 
}
 
 
 
enum Color implements I{
 
    RED(){
 
   public void show(){
 
        }
 
    }, GREEN{
 
   public void show(){
 
        }
 
    }, BLUE{
 
   public void show(){
 
        }
 
    };
 
}
 
 
 
enum Color implements I{
 
    RED(), GREEN, BLUE;
 
    public void show() {
 
    }
 
}

总结:枚举不可以new();即便是反射也不可以!

备注:一个类如果没有构造方法,那么一定有相对应的某个方法可以获取对象!

以上就是关于面向对象的全部想写讲解了,如有不对的地方请联系改正。谢谢!

更多相关内容请访问自学java网:JAVA视频教程

以上就是java——面向对象详细介绍(三)的详细内容,更多请关注自学java网其它相关文章!

声明:有的资源均来自网络转载,版权归原作者所有,如有侵犯到您的权益 请联系邮箱:our333@126.com我们将配合处理!

原文地址:java——面向对象详细介绍(三)发布于2021-11-26 11:20:56