java12-22

封装

1 、什么是封装？

封装就是将属性私有化，提供公有的方法访问私有属性。做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（ getter ）方法和赋值（ setter ）方法，用于对这些属性的访问。如：

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

2、为什么需要封装？

通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。由于取值方法和赋值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强

private修饰符
 
 
package 1_package_private;
 
public class Girl {
    private int age;
    public int getAge(){
        return age;
    }
//将setupAge这个方法封装起来了
    public void setAge(int age){
        if(age >= 30){
            this.age = 18;
        }
        else{
            this.age = age;
        }
    }
}
 
package 1_package_private;
 
public class Test {
    public static void main(String[] args){
        Girl g = new Girl();
        // g.age = 30; //这里不能直接给age赋值，因为age是private修饰的私有的
        g.setupAge(30);
        System.out.println(g.readAge());
    }
}

实际开发中，方法一般会写成setter, getter(Alt+intert键) alt alt

权限修饰符

alt

## private：当前类中可以访问
package 1_package_access;
 
public class A {
    private int age;
    public void eat(){
        System.out.println(age);
        age = 10;
    }
}
package 1_package_access;
 
public class Test {
    public static void main(){
        A a = new A();        //不同类中不可以访问
        //a.age = 100;
    }
}

alt

default：同一个包下可以访问

package 1_package_access;
 
public class A {
    int age;// default默认缺省不写
    public void eat(){
        System.out.println(age);
        age = 10;
    }
}
 
 
package 1_package_access;
 
public class Test {
    public static void main(String[] aegs){
        A a = new A();  //同一个包下可以访问
        a.age = 100;
    }
}

Protected:不同包下的子类中也可以访问

alt public：整个项目中都可以访问属性和方法-修饰符：四种类-修饰符：两种：default和public

继承extends

类是对继承的抽象子类可以不用重复定义父类的属性和方法，提高了代码的复用性父类定义的东西，子类可以直接拿来用父类中private修饰的属性，子类实际上也继承了，因为封装的特性阻碍了直接调用，但是可以通过getter和setter进行间接调用一个父类可以有多个子类，一个子类只能有一个直接父类，Object是所有类的父类 alt

父类

package 1_package_extend;
 
public class Person extends Object{
 
    private int age;
    private String name;
    private double height;
 
    // 提供setter getter方法
    public int getAge() {
        return age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getHeight() {
        return height;
    }
 
    public void setHeight(double height) {
        this.height = height;
    }
 
    // 方法
    public void eat(){
        System.out.println("Can eat");
    }
 
    public void sleep(){
        System.out.println("Can sleep");
    }
 
 
}

子类

package 1_package_extend;
 
public class Student extends Person{// 子类继承父类
    private int sno;
 
    public int getSno() {
        return sno;
    }
 
    public void setSno(int sno) {
        this.sno = sno;
    }
 
    public void study(){
        System.out.println("Can study");
    }
 
 
}
 
package 1_package_extend;
 
public class Test {
    public static void main(String[] args){
        Student s = new Student();
        s.setSno(1001);
        s.setAge(23);
        s.setName("feifei");
        s.setHeight(180.00);
        System.out.println("Studnet's number is: "+ s.getSno()+ "\nhis height is:" + s.getHeight());
    }
}

Idea中加深颜色的是子类的方法，未加深的是父类方法 alt

重写


发生在子类和父类中
在子类中对父类的方法重写
重写有严格的格式要求：要求子类方法名字和父类必须一致，参数列表也要和父类一致（个数，类型，顺序）
 
package joise_package_overwride;
 
public class Person {
    public void eat(){
        System.out.println("can eat");
    }
    public void sleep(){
        System.out.println("can sleep");
    }
}
package joise_package_overwride;
 
public class Student extends Person{
    public void study(){
        System.out.println("can study");
    }
    public void eat(){
        System.out.println("can eat fruits");
    }
}
package joise_package_overwride;
 
public class Test {
    public static void main(String[] args){
        Student s = new Student();
        s.eat();//can eat fruits，这里调用的是子类student中的eat方法
 
    }
}

alt