学习java时候的笔记(十三)

权限修饰符的分类:

有四种,作用分为由小到大分为:(private < 空着不写 < protected < public)

修饰符	同一个类中	同一个包中其它类	不同包下的子类	不同包下的无关类
private	✓
空着不写	✓	✓
protected	✓	✓	✓
public	✓	✓	✓	✓

权限修饰符的使用规则

实际开发中，一般只用private和public

• 成员变量私有
• 方法公开

**特例:**如果方法中的代码是抽取其他方法中共性代码.这个方法一般也私有

代码块

分类:

• 局部代码块
  • 作用提前结束变量的生命周期(已淘汰)
• 构造代码块
  • 抽取构造方法中的重复代码(不够灵活)
• 静态代码块
  • **格式:**static{}
  • **特点:**需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
  • **使用场景:**在类加载的时候，做一些数据初始化的时候使用。

抽象类

• 抽象类∶如果一个类中存在抽象方法，那么该类就必须声明为抽象类
• 抽象方法:将共性的行为（方法）抽取到父类之后。由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。

抽象类的定义格式:public abstract class 类名{}

抽象方法的定义格式:public abstract 返回值类型 方法名(参数列表);

抽象类的作用:

• 抽取共性时，无法确定方法体，就把方法定义为抽象的。
• 强制让子类按照某种格式重写。

抽象类和抽象方法的注意事项:

• 抽象类不能实例化(皇家翻译: 抽象类不能创建对象)
• 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
• 抽象类可以有构造方法
• 抽象类的子类
  • 要么重写抽象类中的所有抽象方法(更多采用)
  • 要么是抽象子类

接口

接口的定义和使用

• 接口用关键字interface来定义

  public interface 接口名{}

• 接口不能实例化(皇家翻译: 接口不能创建对象)

• 接口和类之间是实现关系，通过implements关键字表示

  public class 类名 implements 接口名 {}

• 接口的子类(实现类)

  在实现类中

  • 要么重写接口中所有的抽象方法(更多使用)
  • 要么是抽象类

注意:

• 接口和类的实现关系.可以单实现,也可以多实现。

  public class 类名 implements 接口名1, 接口名2 {}

• 实现类还可以在继承一个类的同时实现多个接口

  public class 类名 extends 父类 implements 接口名1, 接口名2{}

demo

父类Animal

package interfaceDemo1;

public abstract class Animal {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal() {
    }
    public abstract void eat();
}

子类青蛙:
package interfaceDemo1;

public class Frog extends Animal implements Swim{

    @Override
    public void eat() {
        System.out.println("青蛙再吃虫子");
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    public Frog() {
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

子类兔子

package interfaceDemo1;

public class Rabbit extends Animal{

    public Rabbit(String name, int age) {
        super(name, age);
    }

    public Rabbit() {
    }

    @Override
    public void eat() {
        System.out.println("兔子再吃胡萝卜");
    }
}

游泳接口:
package interfaceDemo1;

public interface Swim {
    public abstract void swim();
}

测试类:
package interfaceDemo1;

public class Test {
    public static void main(String[] args) {
        //创建青蛙对象
        Frog f = new Frog("GuaGua",1);
        System.out.println(f.getName() + ", " + f.getAge());
        f.eat();
        f.swim();

        //创建兔子对象
        Rabbit r = new Rabbit("xiaobai",3);
        System.out.println(r.getName() + ", " + r.getAge());
        r.eat();
        //r.swim;   //会报错
    }
}

接口中成员的特点

• 成员变量
  • 只能是常量
  • 默认修饰符: public static final
• 构造犯法
  • 接口中没有构造方法
• 成员方法
  • 只能是抽象方法
  • 默认修饰符:public abstract
  • JDK7以前:接口中只能定义抽象方法。
  • JDK8的新特性:接口中可以定义有方法体的方法。
  • JDK9的新特性︰接口中可以定义私有方法。

接口和类之间的关系

• 类和类的关系
  • 继承关系，只能单继承，不能多继承，但是可以多层继承
• 类和接口的关系
  • 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口和接口的关系
  • 继承关系，可以单继承，也可以多继承
  • **注意:**如果实现类实现了最下面的子接口，那么就需要重写所有的抽象方法

JDK8以后接口中新增的方法

• 允许在接口中定义默认方法，需要使用关键字default修饰
  • 作用:解决接口升级的问题
• 允许在接口中定义定义静态方法，需要用static修饰

接口中默认方法的定义格式:

• 格式:public default 返回值类型 方法名(参数列表){}
  • 范例: public default void show(){}

接口中静态方法的定义格式:

• 格式:public static 返回值类型 方法名(参数列表){}
  • 范例:public static void show(){}

接口中默认方法的注意事项:

• 默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
• public可以省略,default不能省略
• 如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

接口中静态方法的注意事项:

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• public可以省略，static不能省略

JDK9以后接口中新增的方法

JDK9以后接口中新增了私有方法

接口中私有方法的定义格式:

• 格式1:private 返回值类型 方法名(参数列表){} //这种方法服务于默认方法
  • 范例1: private void show(){}
• 格式2:private static 返回值类型 方法名 (参数列表){} 这种方法服务于静态方法
  • 范例2 : private static void method(){}

总结

• 接口代表规则，是行为的抽象。想要让哪个类拥有一个行为，就让这个类实现对应的接口就可以了。
• 当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态。

最后:欢迎大家关注我的公众号