0
点赞
收藏
分享

微信扫一扫

Linux网络配置命令

booksmg2014 2024-06-04 阅读 43

文章目录

抽象

  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. 关键字:

    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{	//定义接口实现类
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }
    @Override
    public 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{
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }

    @Override
    public 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("我是接口中的静态方法");
    }
    
    //重写默认方法
    @Override
    public 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{
          @Override
          public 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{
          @Override
          public void method() {
              System.out.println("重写的method方法");
          }
      
      /*    @Override
          public 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. 类不能多继承,但是接口可以
举报

相关推荐

0 条评论