Java知识点整理(面向对象)方法的重写访问控制修饰符

本文链接：https://blog.youkuaiyun.com/SlimShadyback/article/details/127811844

本文主要介绍了Java中的方法重写，强调了重写规则，并探讨了访问控制修饰符的作用，包括public、private、protected和默认访问级别。此外，还详细讲解了static关键字用于静态变量、静态方法和静态块的情况，以及类中成员变量的分类和初始化建议。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.方法的重写(override/overrideing):重新写,覆盖

发生在父子类中,方法名相同,参数列表相同

重写方法被调用时,看对象的类型------------这是规定,记住就可以


class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我还是想做中餐-------------------不需要重写
class Aoo extends 餐馆{
}
//2)我想改做西餐---------------------需要重写
class Boo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我想在中餐基础之上加入西餐---------需要重写
class Coo extends 餐馆{
    void 做餐(){
        super.做餐();
        做西餐
    }
}

遵循"两同两小一大"原则:-------了解即可一般是一模一样

两同:

方法名相同

参数列表相同

两小:

派生类方法的返回值类型小于或等于超类方法的

void和基本类型时,必须相等

引用类型时,小于或等于

//超类大，派生类小
class Aoo{ //大
    void show(){}
    double test(){ return 0.0; } 
    Boo say(){ return null; }
    Aoo sayHi(){ return null; }
}
class Boo { //小
//int show(){ return 1; } //编译错误，void时必须相同
//int test(){ return 0; } //编译错误，基本类型时必须相同
//Aoo say(){ return null; } //编译错误，引用类型时必须小于或等于
    Boo sayHi(){ return null; } //正确
}

派生类方法抛出的异常小于或等于超类方法的-----------API异常再细说

一大:

派生类方法的访问权限大于货等于超类方法的

2.package和import:

package:声明包

作用:避免类的命名冲突

同包中的类不能同名,单不同包中的类可以同名

类的全称:包名.类名

import:导入类

同包中的类可以直接访问,但不同包中的类不能直接访问,若想访问:

方式1:先import导入类再访问----建议

方式2:类的全称----------------太繁琐不建议

3.访问控制修饰符:---------------------保护数据安全

public:公开的,任何类可访问调用

private:私有的,本类

protected:受保护的,本类,派生类,同包类--------用的很少

默认的:什么也不写,本类,同包类-------------------不建议默认访问权限

注意:

1.访问权限由低到高依次为:private<默认的<protected<public

类的访问权限只能是public或者默认的,而类中成员的访问权限如上四种都可以

package ooday04;
public class Coo {
    public int a; //任何类
    protected int b; //本类、派生类、同包类
    int c; //本类、同包类
    private int d; //本类
    void show(){
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }
}
class Doo{ //-------------------演示private
    void show(){
        Coo o = new Coo();
        o.a = 1;
        o.b = 2;
        o.c = 3;
//o.d = 4; //编译错误
    }
}
package ooday04_vis;
        import ooday04.Coo;
public class Eoo { //演示同包的
    void show(){
        Coo o = new Coo();
        o.a = 1;
//o.b = 2; //编译错误
//o.c = 3; //编译错误
//o.d = 4; //编译错误
    }
}
class Foo extends Coo{ //跨包继承-----演示protected
    void show(){
        a = 1;
        b = 2;
//c = 3; //编译错误
//d = 4; //编译错误
    }
}

4.static:静态的

静态变量:

由static修饰

属于类,存储在方法区中,只有一份

常常通过类名点来访问

何时用:所有对象所共享的数据(图片,音频,视频)

public class StaticDemo {
    public static void main(String[] args) {
        Goo o1 = new Goo();
        o1.show();//a=1,b=1
        Goo o2 = new Goo();
        o2.show();//a=1,b=2
        Goo o3 = new Goo();
        o3.show();//a=1,b=3
        System.out.println(Goo.b); //常常通过类名点来访问
    }
}
//演示静态变量
class Goo{
    int a; //实例变量
    static int b; //静态变量
    Goo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a+",b="+b);
    }
}

静态方法:

由static修饰

属于类,存储在方法区中,只有一份

常常通过类名点来访问

静态方法中没有隐式this传递,所以不能直接访问实例变量

何时用:方法的操作余对象无关(不需要访问对象的属性或者方法)

public class StaticDemo {
    public static void main(String[] args) {
        int a = Ioo.plus(5,6); //常常通过类名点来访问
    }
}
//演示静态方法
class Hoo{
    int a; //实例变量(由对象来访问)
    static int b; //静态变量(由类来访问)
    void show(){ //有隐式this
        System.out.println(this.a);
        System.out.println(Hoo.b);
    }
    static void test(){ //没有隐式this
//静态方法中没有隐式this传递
//没有this就意味着没有对象
//而实例变量a是必须通过对象点来访问的
//所以如下语句发生编译错误
//System.out.println(a); //编译错误
        System.out.println(Hoo.b);
    }
}
//演示静态方法何时用:
class Ioo{
    int a; //实例变量(描述对象的属性)
//show()中访问了对象的属性a，意味着show方法的操作与对象有关，不能设计为静态方法
void show(){
    System.out.println(a);
}
//plus()中并没有访问对象的属性/行为，意味着plus的操作与对象无关，可以设计为静态方法
    static int plus(int num1,int num2){
        int num = num1+num2;
        return num;
    }
}

静态块:

由static修饰

属于类,在类被加载期间自动执行,一个类只被加载一次,所以静态块也只执行一次

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


public class StaticDemo {
    public static void main(String[] args) {
        Joo o4 = new Joo();
        Joo o5 = new Joo();
        Joo o6 = new Joo();
    }
}
//演示静态块
class Joo{
    static{
        System.out.println("静态块");
    }
    Joo(){
        System.out.println("构造方法");
    }
}