JAVA学习 Day7（final、权限、接口）

1 回顾

ArrayList int->Integer char->character
add(E) remove(int index) get(int index)
继承 extends
父类: 子类中共同的成员变量, 成员方法
子类: 会继承父类中所有的成员变量和成员方法
继承: 1 v 1
构造方法的调用 super()
方法的重写: 参数\返回值\方法名 一致
抽象方法:
没有方法体, 直接 ; 结束
需要使用 abstract 来修饰
抽象类: abstract
类中如果有抽象方法, 类就一定是抽象类
不能实例化, 有构造方法
子类继承抽象类, 就必须实现所有的抽象方法

2 权限修饰符

访问控制符/权限修饰符
修饰: 类, [静态]成员变量, [静态]成员方法, 构造方法
public: 公开的, 公共的
protected: 受保护的
(default): 默认的, 不加default关键字, 不写任何内容
private: 私有的

自己类中
同包(没有关系的类)
父子类(不同包)
所有类(即不同包,也不是父子关系)

default: 不常用, 练习时为了省略代码
public : 想要提供给其他类使用的成员
protected: 想要给子类继承的成员

private: 所有的普通成员变量
封装: 为了保证成员变量的安全性, 给设置为私有的
提供给外部访问这个成员变量的方法 get/set

/**
 * 类的封装
 * 成员变量 field: 类中定义的变量
 * 属性: 是有多少对 get/set 方法
 *
 *
 */
public class Student {
    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->protected->default->private
代码体现：
创建一个类，加入不同权限修饰符的方法和变量

package com.zzxx.security;

public class Cat {
    public int a_public = 10;
    protected int b_protected = 20;
    int c_default = 30;
    private int d_private = 40;
    public Cat() {

    }
    public void method1() {
        System.out.println("a_public: " + a_public);
        System.out.println("b_protected: " + b_protected);
        System.out.println("c_default: " + c_default);
        System.out.println("d_private: " + d_private);
    }
    // 给外部获得 d_private 的方式
    public int getD_private() {
        return this.d_private;
    }
    // 给外部提供一个修改 d_private 的方式
    public void setD_private(int d) {
        this.d_private = d;
    }
}

同包不同类

package com.zzxx.security;

public class Demo01CatTest {
    public void m1() {
        Cat cat = new Cat();
        System.out.println("a_public: " + cat.a_public);
        System.out.println("b_protected: " + cat.b_protected);
        System.out.println("c_default: " + cat.c_default);
        cat.c_default = 30;
        // 同包下不能访问私有的成员
//        System.out.println("d_private: " + cat.d_private);
        // 修改私有的成员变量 正确方式
//        cat.d_private = 30;
        cat.setD_private(30);
        // 访问私有的成员变量 正确方式
        System.out.println(cat.getD_private());
    }
}

父类和子类不同包

package com.zzxx.security.chid;

import com.zzxx.security.Cat;

public class TianYuanCat extends Cat {
    public void method02() {
        System.out.println("a_public: " + a_public);
        System.out.println("b_protected: " + b_protected);
        // 不同包的父子类中, 不能访问私有的和默认的成员
//        System.out.println("c_default: " + c_default);
//        System.out.println("d_private: " + d_private);
    }
}

不同包的无关类

package com.zzxx.security.chid;

import com.zzxx.security.Cat;

public class Demo02CatTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println("a_public: " + cat.a_public);
        // 没有任何关系的不同包的其他类中, 只能访问到public的成员
//        System.out.println("b_protected: " + cat.b_protected);
//        System.out.println("c_default: " + cat.c_default);
//        System.out.println("d_private: " + cat.d_private);
    }
}

3 关键字（static，abstract，final）

static: 静态的, 属于类的, 修饰成员变量/成员方法
abstract: 抽象的, 修饰类/成员方法
final: 最终的, 修饰类/成员方法/成员变量/局部变量
修饰类: 类不能被继承
修饰方法: 方法不能被重写
成员变量: 变量不能被修改, 必须初始化
局部变量: 变量不能被修改, 必须初始化
引用类型变量: 引用地址不能被修改, 内容可以修改

常量和字面量相加的情况 范围确定

public class Demo01FinalVariable {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(++a);

        // final修饰局部变量, 只能一次赋值, 不能修改
        final int b; // --> 常量
        b = 20;
//        b = 30;
        System.out.println(b);

        byte b1 = 57;
        b1 = 23 + 34; // 字面量相加, 加完发现在127范围内
        byte b2 = 120;
//        b1 = b2 + 34; // 变量相加, 不确定范围, 认定为int类型, 编译错误
        final byte b3 = 23;
        b1 = b3 + 34; // 常量和字面量, 加完发现范围没有超过
    }
}

final修饰方法无法重写

public class Demo03FinalMethod {
    public void method_normal() {
        System.out.println("Demo03FinalMethod method_normal");
    }
    // final 最终的方法, 不能被重写了
    public final void method_final() {
        System.out.println("Demo03FinalMethod method_final");
    }

    public static void main(String[] args) {
        Demo03FinalMethod demo3 = new Demo03FinalMethod();
        demo3.method_final();
    }
}

public class Demo03Child extends Demo03FinalMethod {
    @Override
    public void method_normal() {
        System.out.println("子类重写完了 normal");
    }
//    public final void method_final() {
//
//    }
}

final修饰的引用变量引用地址无法更改，变量内容可以更改

import com.zzxx.security.Cat;

public class Demo05FinalVariable {
    public static void main(String[] args) {
        final int[] a = {1, 2, 3, 4, 5};
        // final 修饰引用类型变量, 引用-地址不能改变, 对象内容可以改变
        a[0] = 3;
//         a = new int[4];
        final Cat cat = new Cat();
        cat.a_public = 20;
//        cat = new Cat();
    }
}

4 接口 - interface

接口: 特殊的抽象类
抽象类: 可能会存在抽象方法

接口中可以有
不论什么版本
1.公开的抽象方法
2.公开的静态常量
JDK8 开始
3.静态的方法 static
属于接口的, 通过接口直接调用
4.默认的方法 default
通常用来做接口功能的扩展, 可以在实现类中覆盖
JDK9 开始
5.私有方法 private
普通的私有方法: 为了给default方法中的公共代码提取, 实现代码复用
静态的私有方法: 给static方法中公共代码提取的

//1.定义接口InterfaceDemo0
public interface InterfaceDemo0 {
    //全部为公开的抽象方法 需要创建一个实现类来实现接口
    public abstract void fun();
    public void fun1();
    abstract void fun2();
    void fun3();
    //灰色表示现在无意义

    //没有构成方法
    //InterfaceDemo0();//报错：Not allowed in interface

    //成员变量只支持公开静态常量,静态常量必须初始化
    public final static int a = 0;
    int b = 2;//也是静态变量，省略了修饰词

    //1.7新增静态方法
    public static void fun4(){
        System.out.println("接口InterfaceDemo0的static方法");
        fun7();
    }
    //1.8默认方法(默认权限public) - 用于接口功能的扩展
    public default void fun5(){
        System.out.println("接口InterfaceDemo0的default方法");
        fun6();//调用私有方法
    }

    //1.9新增私有方法，用于接口中default方法的代码复用，静态的私有方法给接口静态方法进行代码复用
    private void fun6(){
        System.out.println("接口InterfaceDemo0的private方法");
    }
    private static void fun7(){
        System.out.println("接口InterfaceDemo0的private静态方法");
    }
}

回顾:
在类(静态)方法中, 不能直接调用成员变量和成员方法
成员方法中, 可以直接调用类方法和类变量

使用接口的步骤 implements:实现
1.接口不能直接new对象, 需要一个实现类来 实现接口
public class A implements InterfaceA {

}
将接口中的所有抽象方法 覆盖重写(实现)
2.创建实现类对象, 调用方法
注意事项: 实现类没有覆盖重写(实现)所有的抽象方法, 这个实现类必须是抽象的

//2.定义接口实现类，实现接口中的所有抽象方法
public class InterfaceDemo0Impl implements InterfaceDemo0 {
    //构造方法
    InterfaceDemo0Impl(){
        this.fun();
        System.out.println("创建接口实现类对象时调用构造方法");
    }
    //实现\重写抽象方法
    @Override
    public void fun() {
        System.out.println("重写的fun方法");
    }

    @Override
    public void fun1() {

    }

    @Override
    public void fun2() {

    }

    @Override
    public void fun3() {

    }
}

关系:
1.类和接口: 1 v n implements 实现
2.类和类 : 1 v 1 extends 继承
3.接口和接口: 1 v n extends 继承
4.接口和类: 没有

/*
    一个接口可以继承多个接口
 */
public interface InterfaceC extends InterfaceA, InterfaceB {
    void methodAbsC();

    // 1.InterfaceA 中的抽象方法和默认方法
    // 2.InterfaceB 中的抽象方法和默认方法
    // 3.自己的抽象方法和默认方法,私有,静态
    // 4.如果父接口中有重名的默认方法, 必须重写
    default void methodDefaultA() {

    }
}