java--访问控制符，权限修饰符，方法的重写以及接口与类的关系

1.访问控制符/权限修饰符的解释
修饰: 类, [静态]成员变量, [静态]成员方法, 构造方法
public: 公开的, 公共的
protected: 受保护的
(default): 默认的, 不加default关键字, 不写任何内容
private: 私有的
2.权限范围由大到小: public->protected->default->private
3.分别使用的情况
default: 不常用, 练习时为了省略代码
public : 想要提供给其他类使用的成员
protected: 想要给子类继承的成员
private: 所有的普通成员变量
4. 封装: 为了保证成员变量的安全性, 给设置为私有的
提供给外部访问这个成员变量的方法 get/set
5.JavaBean规范 -> 所有的实体类
1.命名 驼峰命名法
2.成员变量私有化, 提供get/set方法
3.提供空参构造方法
5.static: 静态的, 属于类的, 修饰成员变量/成员方法
abstract: 抽象的, 修饰类/成员方法
final: 最终的, 修饰类/成员方法/成员变量/局部变量
修饰类: 类不能被继承
修饰方法: 方法不能被重写
成员变量: 变量不能被修改, 必须初始化
局部变量: 变量不能被修改, 必须初始化
引用类型变量: 引用地址不能被修改, 内容可以修改
6.方法重写的详细规范:
1.子类中的方法名和参数列表要和父类中一致
@Override 检测这个方法是不是重写, 方法语法不符合重写, 就会报错
如果语法符合, 没有加@Override, 也属于重写
2.子类中的权限, [大于等于] 父类中的方法权限
3.子类中的返回值, [小于等于] 父类中的返回值类型
引用类型 小于等于: Zi -> Fu -> Object Fu->Zi(×)
基本数据类型, 只能相同
Fu fu = new Zi(); // √
Zi zi = new Fu(); // ×
7.接口: 特殊的抽象类
抽象类: 可能会存在抽象方法
存在抽象方法的一定是抽象类
8.接口中可以有
不论什么版本
1.公开的抽象方法
2.公开的静态常量
JDK8 开始
3.静态的方法 static
属于接口的, 通过接口直接调用
4.默认的方法 default
通常用来做接口功能的扩展, 可以在实现类中覆盖
5.私有方法 private
普通的私有方法: 为了给default方法中的公共代码提取, 实现代码复用
静态的私有方法: 给static方法中公共代码提取的
9.关系:
1.类和接口: 1 v n implements 实现
2.类和类 : 1 v 1 extends 继承
3.接口和接口: 1 v n extends 继承
4.接口和类: 没有
10.使用接口的步骤 implements:实现

第一步：创建一个接口，在接口当中定义方法

ublic interface InterfaceAbstractA {
    //定义抽象方法abstractMethod
    void abstractMethod();

    //定义抽象方法abstractMethodB
    void abstractMethodB();

    static void staticMethodC(){
        System.out.println("静态方法");
    }

第二步：接口不能new对象 需要一个实现类来实现接口

 public class  InterfaceAbstractAImpl   implements  InterfaceAbstractA{
    //重写了接口InterfaceAbstract当中的抽象方法abstractMethod
        @Override
        public void abstractMethod() {
            System.out.println("实现方法1");
        }
//重写了接口InterfaceAbstract当中的抽象方法abstractMethodB
        @Override
        public void abstractMethodB() {
            System.out.println("实现方法B");
        }
    }

第三步：创建实现类对象, 调用方法`

public static void main(String[] args){
    //新建一个实现类InterfaceDefaultImpl的对象
    InterfaceDefaultImpl B=new InterfaceDefaultImpl();
    //调用接口中的方法methodDefaultA
    B.methodDefaultA();
    //调用接口中的方法methodDefaultB
    B.methodDefaultB();
    //调用接口中的静态方法methodStaticB
    InterfacePrivateA.methodStaticB();
}

定义成员变量准备测试范围

public class Cat {
    //定义了一个公共的成员变量
      public int a_public=20;
      //定义了一个受保护的成员变量
    protected int b_protected=20;
    //定义了一个默认的成员变量
    int c_default=20;
    //定义了一个私有的成员变量
   private  int d_private=20;

public void xx(){
    //public:公开的,公共的
    //protected:受保护的
    //private:私有的
    //(default)：默认的，不加default关键字，不写任何内容

    // 在自己类中，可以访问到类的public的成员
    System.out.println("a_public"+a_public);
    //在自己类中，允许访问 类的protected成员
    System.out.println("b_protected"+b_protected);
    //在自己类中，允许访问类的default的成员
    System.out.println("c_default"+c_default);
    //在自己类中，允许访问类中私有的成员
    System.out.println("d_private"+d_private);
}

public class Demo02 extends Cat{
    //写一个子类当中的方法xxx
      public void xxx(){
       //在同包，继承关系的子类中，允许访问类的public成员
        System.out.println("a_public"+a_public);
        //在同包，继承关系的子类中，允许访问类的protected成员
        System.out.println("b_protected"+b_protected);
          //在同包，继承关系的子类中，允许访问类的default成员
        System.out.println("c_default"+c_default);
        //在同包，继承关系的子类中，不允许访问类的private成员
       System.out.println("d_private"+d_private);
    }
}