访问控制符/权限修饰符、关系、接口、重写

于 2020-07-14 19:48:52 发布
阅读量281 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LDRaaa/article/details/107346000
版权
本文深入探讨Java的访问控制符及其权限范围，包括public、protected、default和private的使用场景，以及final关键字的特性。同时，详细讲解接口的概念、接口与类的关系，以及接口的实现步骤。

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

一。访问控制符/权限修饰符：
1.修饰: 类, [静态]成员变量, [静态]成员方法, 构造方法
public: 公开的, 公共的。想要提供给其他类使用的成员

protected: 受保护的。想要给子类继承的成员

default: 默认的, 不加default关键字, 不写任何内容

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

权限范围由大到小: public->protected->default->private
在这里插入图片描述

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;
    }
}

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());
    }
}

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);
    }
}

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);
    }
}


/**
 * 类的封装
 * 成员变量 field: 类中定义的变量
 * 属性: 是有多少对 get/set 方法
 */
public class Student {
    private String name;
    private int age;

    public String getName() {//成员对象的get\write
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2.JavaBean规范 -> 所有的实体类

1.命名 驼峰命名法
2.成员变量私有化, 提供get/set方法
3.提供空参构造方法

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

public class Final1 {
    public static void  main(String [] age){
        final int a=10;
        final int b;//主函数中final 修饰可先不初始化

       // a=20;final修饰初始化后不可变
        final int[] c={1,3,2};
        //c=new int[3];
        //final修饰引用类型时地址不可变，但内容可变
        c[0]=4;
    }
}

public class Final2 {
    final修饰成员变量一定要初始化
    final int a=0;
    final int b;{
        b=20;
    }
    //final修饰成员变量可在构造方法中初始化
    final int c;
    Final2(){
        c=20;
    }
    public final void jump(){//final修饰成员方法无法重写
        System.out.println("jhka");
    }
    public  void jum(){
        System.out.println("jhka");
    }
}

public class Final3 extends Final2 {
    @Override
    public void jum() {//只可以重写父类中不是final的成员方法
        super.jum();
    }
}

public final class Final4 {
    /*
    final修饰的类，其成员变量和成员方法无法被其他类继承，无法作为父类
     */
}

4.方法重写的详细规范:
1.子类中的方法名和参数列表要和父类中一致，@Override：表示 检测这个方法是不是重写, 方法语法不符合重写, 就会报错，如果语法符合, 没有加@Override, 也属于重写
2.子类中的权限, [大于等于] 父类中的方法权限
3.子类中的返回值, [小于等于] 父类中的返回值类型
引用类型 小于等于: Zi -> Fu -> Object Fu->Zi(×)
基本数据类型, 只能相同
Fu fu = new Zi(); // √
Zi zi = new Fu(); // ×

public class Fu {
    public int m1() {
        return 0;
    }

    protected long m2() {
        return 0;
    }

    Object m3() {
        return null;
    }

    private void m4() {

    }

    public static void m5() {

    }
}


import java.util.ArrayList;
public class Zi extends Fu {
    @Override
    public int m1() {
        return 0;
    }

    protected long m2() {
        return 0;
    }
    @Override
    public ArrayList m3() {
        return null;
    }
//    @Override
    // 类方法, 不存在重写的概念
//    public static void m5() {
//
//    }
}

二。接口：特殊的抽象类

public interface Interface {//接口
    //接口不是类，没有构造方法
    //接口中成员变量只支持public final static
    //静态常量
    public static final int NUM=10; //final修饰的变量要全部大写

    //jdk7只支持公开的抽象方法
    void method1();
    //jdk8 可以支持默认方法-通常用于功能扩展
    //jdk8 支持静态方法
    default void method2(){
        System.out.println("jdk8可用");
    }
    static void method4() {
        System.out.println("JDK8 才支持的静态的方法");
    }
    //jdk9 可以支持私有方法private
    private void method3(){
        System.out.println("jdk9可用");
    }
}

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

static void abstractMethod3(){//静态接口方法 可以调用静态方法
        System.out.println("接口中静态方法");
        abstractMethod5();
    }


default void abstractMethod2(){//默认接口方法。default前默认有public省略了。
        System.out.println("接口中默认方法");
        abstractMethod4();
        abstractMethod5();//默认方法（成员方法）可调用类的方法

3.使用接口的步骤 implements:实现
1.接口不能直接new对象, 需要一个实现类来 实现接口
public class A implements InterfaceA {
}
将接口中的所有抽象方法 覆盖重写(实现)
2.创建实现类对象, 调用方法
注意事项: 实现类没有覆盖重写(实现)所有的抽象方法, 这个实现类必须是抽象的

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

①来个接口

public interface InterfaceAbstrict {//定义接口
    void abstractMethod();//定义方法。都是抽象方法
    void abstractMethod1();

    default void abstractMethod2(){//默认接口方法。default前默认有public省略了。
        System.out.println("接口中默认方法");
        abstractMethod4();
        abstractMethod5();//默认方法（成员方法）可调用类的方法
    }
    private void abstractMethod4(){//私有接口方法可以给default方法用
        System.out.println("ppp");
        System.out.println("qqq");

    }

    private static void abstractMethod5(){//私有静态接口方法才可以给静态接口方法使用
        System.out.println("ppp");
        System.out.println("qqq");


    }

    static void abstractMethod3(){//静态接口方法 可以调用静态方法
        System.out.println("接口中静态方法");
        abstractMethod5();
    }

}

②创建定义实现类，实现接口

public class InterstractA1Impl implements InterfaceAbstrict {
    //接口方法重写（实现接口抽象方法）接口中抽象和默认方法可以重写
    //要全部重写抽象接口方法
    @Override
    public void abstractMethod() {
        System.out.println("AAAA1");
    }
    @Override
    public void abstractMethod1() {
        System.out.println("aaaa1");
    }
    @Override
    public void abstractMethod2() {
        System.out.println("实现类中重写的默认方法");

    }
    //静态接口方法无法在实现接口类中方法重写
}

③创建实现类对象, 调用方法

public class Main {
    public static void main(String [] ags){
        //实现类创建对象
        InterstractA1Impl m=new InterstractA1Impl();
        //对象调用实现类方法
        m.abstractMethod();
        m.abstractMethod1();

        //若接口中默认方法没被实现类重写，那么此处调用接口中的默认方法abstractMethod2()；
        m.abstractMethod2();
        //若接口中默认方法被实现类重写，那么此处调用类中方法abstractMethod2()；
    }
}

三。关系：
1.接口和接口: 1 v n implements 实现

/*
    一个接口可以继承多个接口
 */
public interface InterfaceC extends InterfaceA, InterfaceB {
    void methodAbsC();
    //可以继承 1.InterfaceA 中的抽象方法和默认方法
    // 2.InterfaceB 中的抽象方法和默认方法
    // 3.自己的抽象方法和默认方法,私有,静态
    // 4.如果父接口中有重名的默认方法, 必须重写
    default void methodDefaultA() {//因父接口重名而重写方法
    }
}

2.类和类：1V1 extends继承：
3.类和接口：1vn extends jicheng

/*
    一个类一定有唯一的父类, 可以有多个父接口
    1.实现多个接口, 将这些接口中所有的抽象方法都实现掉
    2.父类中有抽象方法, 也要实现掉
    3.如果多个接口中,有重复的抽象方法,实现一次即可
    4.如果多个接口中,有重复的default方法,必须要重写一个
 */
public class Zi extends Fu implements InterfaceA, InterfaceB {
    @Override
    public void methodAbsC() {

    }

    @Override
    public void methodAbsA() {

    }

    public void methodZi() {

    }
    public void methodDefaultA() {

    }
}

4.接口和类: 没有

四。命名规则：
1.只能出现：英文 + 数字 + _ + $
2.不能以数字开头
3.变量名：可读性好、首字母小写、第二个单词开始首字母大写
4.包名：全部小写，域名倒写
www.baidu.com
com.baidu.zhidao.xx.xx
com.baidu.baike.xx.xx
5.方法名: 首字母小写、第二个单词开始首字母大写 - 驼峰命名法
长度不限, 但是一定要可读性好
6.类名: 驼峰命名法, 首字母大写
System Scanner Math Arrays
7.常量: final 修饰的变量
全部大写, 多个单词拼接, 使用 _
EXIT_ON_CLOSE 见名知意
静态常量 Math.PI -> 常量字段

LDRaaa
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值