Linux网络配置命令-CFANZ编程社区

文章目录

抽象
- - 抽象的注意事项
  - - static\final\private是否可以修饰抽象方法
    - 继承和抽象知识点回顾
接口

抽象

关键字: abstract
抽象方法:
修饰符 abstract 返回值类型方法名(参数);
抽象类:
public abstract class 类名{ }

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

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

抽象的注意事项

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

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

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

接口

接口是一个引用数据类型

关键字:

interface接口
```
public interface 接口名{ }
```
implements实现
```
实现类 implements 接口名{ }
```

接口中可以定义的成员:
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的方法(实际开发中用的不是特别多)

接口实现总结

定义接口:public interface 接口名{ }
实现:public class 实现类类名 implements 接口名{ }
使用方法:
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();
    }
}

抽象方法

定义格式:public abstract 返回值类型方法名(形参)
注意事项:不写public abstract默认也是有的
使用方法:
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);
    }
}

默认方法

定义格式:

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

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

静态方法

定义格式:

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

使用方法:
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();静态方法可以直接调用接口名
    }
}

成员变量

定义格式：

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

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

注意事项:

被static final修饰的成员变量需要手动赋值
习惯上我们将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);	//修饰的成员变量名称用大写
    }
}

接口的特点

接口可以多继承

public interface InterfaceA extends InterfaceB,InterfaceC{}

接口可以多实现

public class InterfaceImpl implements InterfaceA,InterfaceB{}

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

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方法");
    }
}

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

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);
    }
}

一个子类可以继承一个父类的同时可以是实现一个或者多个接口
```
public class Zi extends Fu implements  InterfaceA,InterfaceB{}
```
注意事项:
1. 只要是父类中或者接口的抽象方法,子类或者实现类都要重写

接口和抽象类的区别

相同点:
1. 都位于继承体系,用于被其他类实现或者继承
2. 都不能new
3. 都包含抽象方法,其子类或者实现类都必须从重写这些抽象方法
不同点:
1. 抽象类:一般作为父类使用,可以有成员变量\构造\成员方法\抽象方法等
2. 接口:成员单一(一般抽取接口)抽取的都是方法,作为实现功能的大集合
3. 类不能多继承,但是接口可以