权限修饰符，代码块，抽象类，接口.Java

1，权限修饰符

权限修饰符：用来控制一个成员能够被访问的范围
可以修饰成员变量，方法，构造方法，内部类

👻👗👑权限修饰符的分类

🧣四种作用范围由小到大(private<空着不写<protected<public)

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

🧣private：私房钱，只能自己用

🧣空着不写：只能本包中能用

🧣protected：受保护的

🧣public：公共的

2，代码块

👻含义：

👻代码块分类

局部代码块：写在方法或语句中的代码块。

📝注意：变量的作用范围只在所属的代码块有效，出了代码块，就无法使用

📝作用：提前结束变量的声明周期

构造代码块

写在成员位置的代码块，在创建本类对象时，会优先与构造方法执行（每次创建对象时都会执行）。可以把多个构造方法中重复的代码写在构造代码块中。（这个方法过于死板，一般采用下面两个方法）

静态代码块

格式：static{}，在构造代码块的基础上加了static

特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次。

3，抽象类

一、什么是抽象类

🍑我们之前学过什么是类，那么抽象类是不是也是类的一种呢？

听名字就感觉好抽象呀！说对了，他就是抽象的，不是具体的。在类中没有包含足够的信息来描绘一个具体的对象，这样的类称为抽象类。

🌰来看一个抽象类的例子

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

大家觉得这个抽象类是不是什么也没干，他唯一的方法draw()还是空的。

像这样的类是不是就没有包含足够的信息来描绘一个具体的对象，自然也就不能实例化对象了。不信你看：

🍑那既然一个类不能实例化，那这种抽象类存在的意义是什么呀🤔？别急，存在即合理，听我慢慢道来。

二，抽象类在实现多态中的意义

🍑抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态。

来看一段代码

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重写抽象类中的draw方法
        System.out.println("画一个圆圈");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象类虽然不能直接实例化
        // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
        Shape shape = new Cycle(); // 这称作：向上转型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

运行之后你就会发现神奇的一幕：

📝什么是向上转型：一句话总结就是“父类引用指向子类对象”

向上转型后的变化

🏀关于方法：父类引用可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），但子类特有的方法无法调用。
🏀关于属性: 父类引用可以调用父类的属性，不可以调用子类的属性

向上转型的作用

🐟减少一些重复性的代码
🐟对象实例化的时候可以根据不同需求实例化不同的对象

🌰这样的话就我们上面的代码就可以理解了

🎀看来，我们可以通过子类对抽象类进行继承和重写，抽象类还真有点用呀！

🍑但这和多态有什么关系呢，抽象类用起来这么麻烦，我还不如直接用普通类，也能达到这样的效果，还不用再写一个子类呢😫？

🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

🌰那行，你再看看下面的代码，你就知道抽象类在实现多态时的好处了。

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子类引用cycle
        Flower flower = new Flower(); // 子类引用flower
        Square square = new Square();
        
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
 
            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }
 
    }
}

✨结果

🎠调用同一个方法竟然打印出了不同的结果😮，这难道就是所谓的多态🤔

🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶🧶

🎃原因就是

// 对上面的代码补充一下
// 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
// 但上面的代码就相当于 
 
 Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀！数组大小为3
 
// (将指向->子类对象)的子类引用赋值给父类对象，不就相当于该夫类引用指向->所对应的子类对象吗
//这是向上转型的另一种写法，应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
 shapes1[0] = cycle;  // 如果前面没实例化子类对象，就要写成shape1[0] = new Cycle
 shapes1[1] = flower;
 shapes1[2] = square;

🎈对于多态来说，他有这三个要素

继承（我们刚才的Cycle类继承Shape抽象类）
重写（我们子类对draw方法的重写）
父类指向子类对象（就是shape1[0] = cycle -->也可以称作向上转型)

🍑回头再看一下我们的代码，是不是就刚好符合了多态的三要素😉。

📝当我们的父类引用指向不同的子类对象时，当我们调用同一个draw方法时却输出了不同的结果。（其实就是该方法再子类中被重写成了不同形式）这就叫做多态。

嘻嘻😂，其实只要只要结合着例子来看，多态也没那么难理解呀😎

🍑那为啥一定要用抽象类呢😂？我一个普通类继承普通类来实现多态不可以吗🤔

🌰当然可以，但不太安全有风险；

但如果是抽象类的话，就不一样了😉

🍑从这我们也可以看出，当用抽象类的时候，编译器自动就对我们是否重写进行了校验，而充分利用编译器的校验, 在实际开发中是非常有意义的。所以说抽象类还是有用的，嘻嘻😉

📝好了，相信到这里你对抽象类也有了一个大概的认识😊，下面我们来简单做一下总结

使用abstract修饰的类或方法，就是抽象类或者抽象方法
抽象类不能具体的描述一个对象，也就是说不能实例化对象
抽象类里面的成员变量，都是和普通的类一样；成员方法要加abstract，且没有结构体
当一个普通类继承抽象类是，这个普通类必须重写抽象类中所有的抽象方法（🍑因为我们之前说抽象类不是具体的，没有包含足够的信息来描述一个对象，所以我们必须把他补充完整）
但当一个抽象类A继承了抽象类B，这时抽象类A就可以不重写抽象类B中的抽象方法
final不能修饰抽象类和抽象方法（抽象类存在的最大意义就是被继承，而被final修饰的类不能被重写，final和抽象，它们两个就是天敌🎈🎈🎈🎈）
抽象方法不能被private修饰（抽象方法就是被重写的，被private修饰了，还怎么重写）
抽象类中不一定有抽象方法，但一个类中由抽象方法，那么这个类一定是抽象类

🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

4，接口

一，介绍

👻🧣👑🥇🧸接口用于描述类具有什么功能，但不给出具体实现，当某个类要使用接口时，再去实现接口中的方法。类需要遵循接苦衷描述的统一规则进行定义，所以接口是对外提供的一组规则，标准。

二，定义

🦄定义接口要用到关键字interface

interface 接口名{}

🦄类和接口之间不是继承关系，而是实现关系，用implements关键字表示。

class 类名 implements 接口名{}

🧩需要注意的是：与类的定义相似，接口的访问权限修饰符只能是public或者默认

三，特点

🎨🎨接口成员变量的特点🎨🎨：没有成员变量，只有公共静态常量，即在默认情况下都会有public static final 这三个关键字修饰。如下：

public static final 数据类型常量名=常量值；

🧩注意：final关键字中要求，final属性必须初始化，而对于共有静态常量（public static final)，初始化的途径只有两条------①定义时显示初始化；②在静态代码块中初始化。但是，接口中不允许出现代码块，而且接口中没有构造方法。因此，要求我们在接口中定义公共静态常量时，必须在定义时就赋值。否则IDEA就报错。

🎨🎨接口成员方法的特点🎨🎨：

①在TDK7.0版本及其之前的版本中，接口中仅支持只有公共抽象方法。如下：

public abstract 返回值类型方法名（）；

🧩事实上，接口中的方法默认就是共有抽象方法，因此在定义时省略也可以。

②从JDK8.0开始就可以有默认方法和静态方法：

默认方法-----public default 返回值类型方法名（）{}
静态方法-----public static 返回值类型方法名（）{}

🧩注意，想要在接口中定义默认方法必须在前面加default关键字 ，因为接口中的方法你什么都不写，默认的就是共有抽象方法。默认方法可以有方法体，且不需要实现类取实现，其实就是我们平时见到的普通成员方法。但是默认方法是可以被实现重写的（不需要强制重写，需要用到再重写）。default关键字只能在接口中使用，就算实现类要重写方法也不能添加default修饰符，不然JDK报错；如果实现多个接口，不同接口中方法名相同，就必须要重写。

🧩静态方法只能通过接口名调用，不能通过类名或对象名进行调用，且不能被重写（重写是对虚方法表里面的方法进行重写覆盖掉，而static，final，private不在虚方法表里面）

③JDK9.0以后，接口中可以有私有方法（private和private static）