修饰符的介绍使用及注意事项

private （缺省） protected public

private > 缺省（不输入） > protected > public

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

protected         访问使用方法

final的作用

1. final关键字是最终的意思，可以修饰（类、方法、变量）
2. 修饰符：表明该类是最终类，不能被继承
3. 修饰方法：表明该类方法是最终方法，不能被重写
4. 修饰变量：表示该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）

修饰变量分为一下几种：

• 局部变量
• 成员变量（实例成员变量、静态成员变量）

1. 静态成员变量（常量static）；
2. 实例成员变量

注意：

• final修饰的变量是基本类型：那么变量存储的数据值不能发生改变
• final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但地址指向的对象内容是可以发生变化的

常量的定义：final

提高系统的可维护新和可读性

public class Constant{
    public static final String SCHOOL_NAME="常量";
    public static final int UP = 1;
    public static final int DOWN = 2;
    public static final int LEFT = 3;
    public static final int RIGHT = 4;
}

案例展示

package com.it.d1;

import javax.swing.*;
import java.awt.event.ActionEvent;

public class Test {
    public static final int UP=1; //上
    public static final int DOWN=2;//下
    public static final int LEFT=3;//左
    public static final int RIGHT=4;//右
    public static void main(String[] args) {
//        创建一个窗口对象（桌子）
        JFrame win =new JFrame();
//        创建一个面板对象（桌布）
        JPanel panel=new JPanel();
//        把桌布垫在桌子上
        win.add(panel);
//        创建4个按钮对象
        JButton btn1=new JButton("上");
        JButton btn2=new JButton("下");
        JButton btn3=new JButton("左");
        JButton btn4=new JButton("右");
//        把按钮对象添加到桌布上去
        panel.add(btn1);
        panel.add(btn2);
        panel.add(btn3);
        panel.add(btn4);
//        显示窗口
        win.setLocationRelativeTo(null);
        win.setSize(300,400);
        win.setVisible(true);

//        点击按钮触发
        btn1.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                MOVE(UP);
            }
        });
        btn2.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                MOVE(DOWN);
            }
        });
        btn3.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                MOVE(LEFT);
            }
        });
        btn4.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                MOVE(RIGHT);
            }
        });
    }
//    按钮触发事件
    public static void MOVE(int btn){
        switch (btn){
            case UP:
                System.out.println("向上移动");
                break;
            case DOWN:
                System.out.println("向下移动");
                break;
            case LEFT:
                System.out.println("向左移动");
                break;
            case RIGHT:
                System.out.println("向右移动");
                break;
        }
    }
}

abstract的作用

• abstract是抽象的意思，可以修饰类、成员方法。
• abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
• 使用场景：抽象类是不完整的设计图，一般作为父类，让子类继承该行为（子类继承后重写该方法）

修饰符  abstract class 类名 {
    修饰符 abstract 返回值类型 方法名称（形参列表）
}


//定义抽象方法，让子类继承必须完成这个方法
public abstract class Animal{
    public abstract void run()
}

//子类继承父类
public class Dog extends Animal{
    //对方法进行重写并完成该方法
    @Override
    public void run(){
        System.out.println("狗狗跑得贼快")
    }
}

抽象方法的理解

• 类有的东西，抽象类都有
• 抽象类中不一定有抽象方法，抽象方法中一定有抽象类
• 一个类继承了抽象类，必须重新完抽象类的全部抽象方法，否则这个抽象类也必须定义成抽象类
• 不能使用abstract修饰变量、代码块、构造器
• 重要特征：抽象类不能创建对象

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

Animal a=new Animal()  //报错  抽象类不能创建对象

final和abstract的关系

• 互斥关系 final定义的类不能被继承/重新   abstract定义的抽象类为模板，只能让子类继承

//类1  运行
public class Test{
    public static void main(String[] args){
        StudentMinddle s = new StudentMiddle;
        s.write();
        
        StudentChild S2 = new StudentChild();
        s2.write();
    }
}

//类2  模板
public abstract class Student{
    public final void write(){
        System.out.println("模板方法"); //模板
        System.out.println(writeMain()); //重新方法
    }
    public abstract String writeMain();//定义需要重新的方法
}

//类3  继承类并使用定义的重新方法
public class StudentChild extends Student{
    @Override
    public String writeMain(){
        return "重新内容输入"
    }
}