JAVASE基础（类的封装，继承）

 一：类的封装

（1）什么是类的封装？

        将对象的属性隐藏在对象的内部，只能在本类中使用，不允许外部程序直接访问对象内部信息。可以通过该类所提供的构造方法来实现对内部信息的操作和访问。

（2）封装的目的

   1.属性私有化，隐藏类的实现细节

   2.便于修改，提高代码的可维护性

（3）封装的设计原则

   1.private: 类内部能访问, 类外部不能访问，可以对外提供公开的方法。

   代码示例：

package Face;
//定义一个顾客类型
1.声明
public class Customer {
    //属性
    //成员变量，实例变量，非静态变量
    //int  age;
    private int age;//private修饰的数据只能在本类中访问
 
    //对外提供两个公开的方法
    //set 赋值
    public void setAge (int _age){
        if(_age<0||_age>100){
            System.out.println("年龄不合法");
        }
        age = _age;
    }
    //get 读取
    public int getAge (){//成员方法，实例方法，非静态方法，必须使用”引用.“的方式访问
 
        return age;
    }
 
     static class Test02 {
        public static void main(String[] args) {
            //如果是private类
            // 2.创建Customer类型的对象
            Customer cus = new Customer();
            //3.赋值
            cus.setAge(-10);
            cus.setAge(10);
            //4.读取
            int age = cus.getAge();
            System.out.println(age);
        }
    }
}
/*输出结果：
年龄不合法
10
*/

   注意：

         对外提供公开的 set方法和get方法的方法名应该遵循规范：set/get+属性名，set有参 数，get无参数。

        类中大部分成员变量都应该用private修饰（全局变量用public修饰）

   2.protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.

   代码示例：

// Animal.java
public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
   }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
   }
}
// Bird.java
public class Bird extends Animal {
    public Bird(String name) {
        super(name);
   }
    public void fly() {
        // 对于父类的 protected 字段, 子类可以正确访问
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
   }
}
// Test.java 和 Animal.java 不在同一个 包 之中了. 
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("小动物");
        System.out.println(animal.name); // 此时编译出错, 无法访问 name
   }
}

 注意：

       对于类的调用者来说, protected 修饰的字段和方法是不能访问的。

       对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的。

二：类的继承

（1）什么是类的继承？

         有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关

联。那么就可以通过面向对象程序设计使代码复用，允许程序员在保持原有类特性的基础上进行扩

展，增加功能，这样产生新的类，称派生类。

（2）目的：达到代码重用的效果（现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法）

（3）命名规则：

        被继承的类称为：父类，基类或超类。

        新的类称为：子类，派生类。

（4）语法规则：

        [修饰符列表] class 子类名 extends 父类名{

               类体；

       }

public class 子类 extends 父类 {
    类体;
}

（5）代码示例：

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
   }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
   }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 调用父类的构造方法. 
        super(name);
   }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
   }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
   }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
   }
}

（6）注意：

   1.Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

   2.子类会继承父类的所有 public 的字段和方法.

   3.对于父类的 private 的字段和方法, 子类中是无法访问的，可以通过引用公开的方法。