Java面向对象中的---方法的重写，访问控制修饰符，static

本文链接：https://blog.csdn.net/xiao610212b/article/details/126329840

1. 方法的重写(override/overriding)：重新写

发生在父子类中，方法名相同，参数列表相同
重写方法被调用时，看对象的类型

2. 重写与重载的区别：

重写(override)：发生在父子类中，方法名相同，参数列表相同
重载(overload)：发生在同一类中，方法名相同，参数列表不同

3. package和import：

package：声明包
- 作用：避免类的命名冲突
- 同包中的类不能同名，但是不同包中的类可以同名
- 类的全称：包名.类名，包名常常有层次结构
- 建议：包名所有字母都小写
import：导入类
- 同包中的类可以直接访问，而不同包中的类不能直接访问，若想访问：
  - 先import导入类，再访问---------建议
  - 类的全称-------------------------------太繁琐，不建议

4. 访问控制修饰符：---------------------------保护数据的安全

public：公开的，任何类
private：私有的，本类
protected：受保护的，本类、派生类、同包类-----------应用率低

默认的：什么也不写，本类、同包类-------------------------java不建议默认权限

说明：

类的访问权限，只能是public或默认的
类中成员的访问权限，如上4种都可以
访问权限由低到高依次为：private<默认的<protected<public

package ooday04;
//演示访问控制修饰符
public class Aoo {
    public int a;    //任何类
    protected int b; //本类、派生类、同包类
    int c;           //本类、同包类
    private int d;   //本类

    void show(){
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }
}

class Boo{ //-------------------演示private
    void show(){
        Aoo o = new Aoo();
        o.a = 1;
        o.b = 2;
        o.c = 3;
        //o.d = 4; //编译错误
    }
}

package ooday04_vis;
import ooday04.Aoo;

public class Coo { //----------------演示同包的
    void show(){
        Aoo o = new Aoo();
        o.a = 1;
        //o.b = 2; //编译错误
        //o.c = 3; //编译错误
        //o.d = 4; //编译错误
    }
}

class Doo extends Aoo{ //跨包继承-----------演示protected
    void show(){
        a = 1;
        b = 2;
        //c = 3; //编译错误
        //d = 4; //编译错误
    }
}

5. static：静态的

静态变量：

由static修饰
属于类，存储方法区中，只有一份
常常通过类名点来访问

何时用：所有对象所共享的数据(图片、音频、视频等)

public class StaticDemo {
    public static void main(String[] args) {
        Eoo o1 = new Eoo();
        o1.show();
        Eoo o2 = new Eoo();
        o2.show();
        Eoo o3 = new Eoo();
        o3.show();
        System.out.println(Eoo.b); //常常通过类名点来访问
    }
}

//演示静态变量
class Eoo{
    int a;
    static int b;
    Eoo(){
        a++;
        b++;
    }
    void show(){
        System.out.println(a+","+b);
    }
}

静态方法：

由static修饰
属于类，存储方法区中，只有一份
常常通过类名点来访问
静态方法中没有隐式this传递，所以不能直接访问实例成员

何时用：方法的操作与对象无关(方法中不操作对象的属性和行为)

public class StaticDemo {
    public static void main(String[] args) {
        Foo.test(); //常常通过类名点来访问
    }
}


//演示静态方法
class Foo{
    int a; //实例变量(对象来访问)
    static int b; //静态变量(类名点来访问)
    void show(){ //有this
        System.out.println(this.a);
        System.out.println(Foo.b);
    }
    static void test(){ //没有this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a是必须由对象来访问的
        //所以如下语句发生编译错误
        //System.out.println(a); //编译错误
        System.out.println(Foo.b);
    }
}

//演示静态方法何时用
class Goo{
    int a; //描述的是对象的属性

    //在show()方法中访问了对象的属性a，说明该方法与对象有关，不能设计为static方法
    void show(){
        System.out.println(a);
    }
    //在plus()方法中不需要访问对象的属性，说明该方法与对象无关，可以设计为static方法
    static int plus(int num1,int num2){
        int num = num1+num2;
        return num;
    }
}

静态块：

由static修饰
属于类，在类被加载期间自动执行，因一个类只被加载一次，所以静态块也只执行一次

何时用：初始化/加载静态资源(图片、音频、视频等)

public class StaticDemo {
    public static void main(String[] args) {
        Hoo o4 = new Hoo();
        Hoo o5 = new Hoo();
        Hoo o6 = new Hoo();
    }
}

//演示静态块
class Hoo{
    static{
        System.out.println("静态块");
    }
    Hoo(){
        System.out.println("构造方法");
    }
}