初识JAVA08:private关键字、封装、继承、访问权限修饰符的权限范围

面向对象

private关键字

private 私有的

​ 成员修饰符,只能修饰成员,不能修饰局部的

​ 一个成员一旦私有,只能在本类中使用,外部类无法使用

私有的成员需要配合公共的访问方式一起使用–>方法

​ 设置器 setter

​ 访问器 getter

私有的属性配合公共的访问方式就能够实现安全么??

​ 1.不能直接访问操作成员 2.设置器或者访问器中,方法中可以进行逻辑的判断等…

注意:

​ 定义的模板类中的属性都要私有化,并提供一对公共的访问方式

public class StudentTest {
    public static void main(String[] args) {
        Student st = new Student();
        st.setName("张三");
        st.setAge(18);
        st.setScore(100);
        st.info();

    }
}

class Student{
    private String name;
    private int score;
    private int age;

    public Student(){}
	//设置器
    public void setName(String name) {
        this.name = name;
    }

    public void setScore(int score){
        this.score = score;
    }

    public void setAge(int age){
        this.age = age;
    }
	//访问器
    public String getName(){
        return name;
    }

    public int getScore(){
        return score;
    }

    public int getAge(){
        return age;
    }

    public void info(){
        System.out.println("姓名:"+name+",年龄:"+age+",成绩:"+score);
    }
}

封装

面向对象的三大特性: 封装 继承 多态

​ 封装: 隐藏内部的实现细节,对外提供公共的访问方式

​ 优点:

​ 隐藏内部的实现细节,对外提供公共的访问方式

​ 提高安全性

​ 提高复用性

​ 体现:

​ 类,方法等都是封装的体现

​ 属性私有化是封装的体现

​ 私有是封装

​ 封装不仅仅是私有

JAVABEAN 指代一些列类

​ 代表模板类,根据对象抽取共性定义的类,统一称为javabean

​ 定义javabean的规范:

​ 1.类是公共的

​ 2.至少提供一个空构造,按需提供带参

​ 3.属性私有化

​ 4.公共的访问方式

继承

面向对象的三大特性之一:继承

​ 继承:子承父业

​ 目的:为了提高代码的复用性

​ 使用:子类 exyends 父类

​ 派生类|子类:对象的抽象

​ 超类|基类|父类:是对子类的抽象

​ 子类一旦继承父类,就有权使用父类中的成员,被private修饰的成员,只能继承没有权限直接访问,可以通过父类中的设置器和访问器访问

​ 构造函数不能被继承

​ 子类是父类的延续(使用父类的内容)+扩展(定义子类独有的内容)

​ 一个父类可以存在多个子类

​ 单继承机制-> 一个子类只能存在一个父类

​ 单继承:

​ 优点:简单,提高代码的复用性

​ 缺点:不够灵活,不便于后期维护,耦合度比较高

​ 多实现->接口

​ 面向对象的设计原则之一:开闭原则

​ 为修改关闭,为扩展开放

public class ExtendsDemo01 {
    public static void main(String[] args) {
        Dog dog = new Dog("二哈",2,"哈士奇");
        dog.run();
    }


}

class Animal{
    private String name;
    private int age;
    private String brand;

    public Animal() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void run(){
        System.out.println(name+"在飞快地奔跑...");
    }
}

class Dog extends Animal{
    public Dog(){

    }

    public Dog(String name,int age,String brand){
        setName(name);
        setAge(age);
        setBrand(brand);
    }

}

访问权限修饰符的权限范围

访问权限修饰符:某一个成员被访问的限定范围

访问权限修饰符	本类	同包下的类	不同包下的子类	不同包下的其他的类
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

所有的访问权限修饰符都是成员修饰符,只能修饰成员,不能修饰局部(局部内容不能被外部访问)

能够修饰类的:public和default(默认的,省略不写,写上会报错)

当类或者成员前面不写权限修饰符的时候,默认为default,但是不能在前面直接写default

如果想要使用父类中继承的,被protected修饰的成员,需要在子类中并通过继承关系使用

私有的内容只能在本类中直接使用

package com.xxx.demo;
//本类
public class ModifierDemo {
    public static int a;
    protected static int b;
    static int c;
    private static int d;
	protected  int e;
    
    public static void main(String[] args) {
        System.out.println(ModifierDemo.d);//private
    }
}

//同包下的类
class ModifierTest1 {
    public static void main(String[] args) {
        System.out.println(ModifierDemo.c);//default
    }
}

package com.xxx.demo1;
import com.xxx.demo.ModifierDemo;
//不同包下的子类
public class ModifierTest2 extends ModifierDemo{
    public static void main(String[] args) {
        System.out.println(b);//protected,子类中继承直接调用
        ModifierTest2 m2 = new ModifierTest2();
        System.out.println(m2.e);//protected,子类中继承直接调用
        ModifierDemo m = new ModifierDemo();
        //System.out.println(m.e);//protected,子类中非继承直接调用,报错
    }
}

package com.xxx.demo1;
import com.xxx.demo.ModifierDemo;
//不同包下的类
public class ModifierTest3{
    public static void main(String[] args) {
        System.out.println(ModifierDemo.a);//public
    }
}