一个小时搞定JAVA面向对象（5）——抽象与接口

抽象

1. 关键字: abstract

2. 抽象方法:
   修饰符 abstract 返回值类型 方法名(参数);

3. 抽象类:
   public abstract class 类名{ }

public abstract calss pet{String name;/*父类中的方法,我们可以仅仅定义为一个声明,具体的实现交给子类去实现*/public abstract void eat();
}

注意:
a.抽象方法所在的类一定是抽象类
b.抽象类中不一定非得有抽象方法
c.子类继承父类之后,需要重写父类
中所有的抽象方法,不然编译报错
d.抽象类不能new对象,只能通过new子类对象调动重写方法

抽象的注意事项

1. 抽象类不能直接new对象,只能创建非抽象子类的对象
2. 抽象类中不一定非得有抽象方法,但是抽象方法所在的类一定抽象类
3. 抽象类的子类,必须重写父类中的所有抽象方法,否则,编译报错,除非该子类也是抽象类
4. 抽象类中可以有成员变量,构造,成员方法
5. 抽象类中可以有构造方法,是供子类创建对象时,初始化父类属性使用的
6. 抽象类虽然不能被实例化,但是可以通过多态的方法来赋值
7. 作为抽象类的子类

没有抽象方法的抽象类意义是啥?

为了不让外界创建对象,被实例化.

static\final\private是否可以修饰抽象方法

1. **static和abstract：**是不能够共存的。static是为方便调用，abstract为了给子类重写的，没有方法体
2. **final和abstract：**是相互冲突的，final修饰的方法不能被重写，而abstract修饰的方法就是为了让子类重写的。
3. **private和abstract：**也是冲突的，private修饰

继承和抽象知识点回顾

1. 继承:子类继承父类,可以直接使用父类中非私有成员,子类不用写重复性代码
2. 关键字: extends
3. 成员访问特点:
4. 成员变量:看等号左边是谁
5. 成员方法:看new的是谁
6. 方法的重写:子类中有一个和父类从方法名以及参数列表上一样的方法
7. 检测:@Override
8. 使用场景:功能的升级
9. 继承中构造的特点:
10. new子类对象先初始化父类
11. super:代表的是父类引用
12. 调用父类构造:super() super(实参)
13. 调用父类成员变量: super.成员变量名
14. 调用父类成员方法:super.成员方法名(实参)

7.this:代表的是当前对象(哪个对象调用的this所在的方法,this就代表哪个对象)

​ a.作用:区分重名的成员变量和局部变量

​ b.使用:

​ 调用当前对象构造:this() this(实参)

​ 调用当前对象成员变量:this.成员变量名

​ 调用当前对象成员方法:this.成员方法名(实参)

​ c.注意:在构造中使用this和super,都必须要在第一行,所以两者不能同时出现

8.继承的特点:

​ a.继承只支持单继承,不支持多继承

​ b.继承支持多层继承

​ c.一个父类可以拥有多个子类

9.抽象:

​ a.抽象方法: 修饰符 abstract 返回值类型 方法名(形参)

​ b.抽象类:public abstract class 类名{}

​ c.特点:

​ 抽象方法所在的类一定是抽象类

​ 抽象类中不一定非得有抽象方法

​ 子类继承抽象父类时,需要重写抽象方法

​ 抽象类不能new对象,只能new子类对象

​ 抽象类中啥都可以有,私有属性,构造,其他方法等

​ 抽象类中的构造是供创建子类对象时初始化父类属性使用的

接口

1. 接口是一个引用数据类型

2. 关键字:

   1. interface接口

      public interface 接口名{ }
      

   2. implements实现

      实现类 implements 接口名{ }
      

3. 接口中可以定义的成员:

   1. JDK7以及比之前:
      1. 抽象方法
         public abstract ( 即使不写public abstract,默认也有)
      2. 成员变量
         public static final 数据类型 变量名 = 值
         (即使不写public static final,默认也有)
         (final是最终的,被final修饰的变量不能二次赋值,所以我们一般将final修饰的变量视为常量)
   2. JDK8:
      1. 默认方法
         public default 返回值类型 方法名(形参){}
      2. 静态方法
         public static 返回值类型 方法名(形参){}
   3. JDK9开始:
      1. 私有方法
         1. private的方法(实际开发中用的不是特别多)

接口实现总结

1. 定义接口:public interface 接口名{ }
2. 实现:public class 实现类类名 implements 接口名{ }
3. 使用方法:
   1. 实现类实现接口
   2. 重写接口中的抽象方法
   3. 创建实现类对象(接口不能new对象)
   4. 调用重写的方法

//接口实现代码案例
public interface USB {	//定义接口public abstract void open();public abstract void close();
}public class Mouse implements USB{	//定义接口实现类@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic void close() {System.out.println("鼠标关闭");}
}public class Test01 {	//测试类public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();mouse.close();}
}

抽象方法

1. 定义格式:public abstract 返回值类型 方法名(形参)
2. 注意事项:不写public abstract默认也是有的
3. 使用方法:
   1. 定义实现类\实现接口
   2. 需要重写抽象方法
   3. 创建实现类对象,调用重写的方法

public interface USB {//定义抽象方法public abstract void open();String close();
}//调用抽象方法制作实现类
public class Mouse implements USB{@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic String close() {return "鼠标关闭";}
}public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();String result = mouse.close();System.out.println("result = " + result);}
}

默认方法

1. 定义格式:

   public default 返回值类型 方法名(形参){方法体return 结果
   }
   

2. 使用方法:

   1. 定义实现类\实现接口
   2. 默认方法可以重写,也可以不重写
   3. 创建实现类对象,调用默认方法

静态方法

1. 定义格式:

   public static 返回指类型 方法名(形参){方法体retuan 结果
   }
   

2. 使用方法:

   1. 接口名直接调用

默认方法和静态方法的作用：

可以作为临时加的一个小功能来使用

public interface USB {//默认方法public default void methodDef(){System.out.println("我是默认方法");}
}
public class Mouse implements USB {//默认方法public default void methodDef(){System.out.println("我是默认方法");}//静态方法public static void methodSta(){System.out.println("我是接口中的静态方法");}//重写默认方法@Overridepublic void methodDef(){System.out.println("我是重写接口中的默认方法");}
}
public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.methodDef();System.out.println("=============");USB.methodSta();静态方法可以直接调用接口名}
}

成员变量

1. 定义格式：

    public static final 数据类型 变量名 = 值
   

2. 使用方法：

   1. 接口名直接调用
   2. 可不写public static final ,默认会有

3. 注意事项:

   1. 被static final修饰的成员变量需要手动赋值
   2. 习惯上我们将static final修饰的成员变量名称用大写

   public interface USB {public static final int NUM1 = 100;int NUM2 = 200;//不写public static final 默认也有
   }public class Test01 {public static void main(String[] args) {System.out.println(USB.NUM1);System.out.println(USB.NUM2);	//修饰的成员变量名称用大写}
   }
   

接口的特点

1. 接口可以多继承

   public interface InterfaceA extends InterfaceB,InterfaceC{}
   

2. 接口可以多实现

   public class InterfaceImpl implements InterfaceA,InterfaceB{}
   

   1. 当一个类实现多个接口时,如果接口中的抽象方法有重名并且参数一样,只需要重写一次

      public interface InterfaceA {public abstract void method();
      }public interface InterfaceB {public abstract void method();
      }public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}
      }
      

   2. 当一个类实现多个接口时,如果多个接口中的默认方法有重名的且参数一样,必须重写一次默认方法

      public interface InterfaceA {public abstract void method();public default void methodDef(){System.out.println("我是接口A中的默认方法");}
      }public interface InterfaceB {public abstract void method();/*    public default void methodDef(){System.out.println("我是接口B中的默认方法");}*/public default void methodDef(int a) {System.out.println("我是接口B中的默认方法");}
      }public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}/*    @Overridepublic void methodDef() {System.out.println("重写后的默认方法");}*/
      }public class Test01 {public static void main(String[] args) {InterfaceImpl anInterface = new InterfaceImpl();anInterface.methodDef();anInterface.methodDef(10);}
      }

3. 一个子类可以继承一个父类的同时可以是实现一个或者多个接口

   public class Zi extends Fu implements  InterfaceA,InterfaceB{}
   

4. 注意事项:

   1. 只要是父类中或者接口的抽象方法,子类或者实现类都要重写

接口和抽象类的区别

• 相同点:

  1. 都位于继承体系,用于被其他类实现或者继承
  2. 都不能new
  3. 都包含抽象方法,其子类或者实现类都必须从重写这些抽象方法

• 不同点:

  1. 抽象类:一般作为父类使用,可以有成员变量\构造\成员方法\抽象方法等
  2. 接口:成员单一(一般抽取接口)抽取的都是方法,作为实现功能的大集合
  3. 类不能多继承,但是接口可以

java中类\抽象类\接口之间的区别:

1. 类中不能有抽象方法
2. 抽象类中可以有抽象方法,也可以有非抽象方法
3. 接口中只能由抽象方法,接口中的所有方法均为public abstract