封装和继承1（Java）

1. 封装的概念和思想

封装：将类的信息隐藏在类的内部，不让外部直接访问，而是提供便捷的接口供外界访问

封装步骤：

1.属性私有 将属性都使用private修饰 被private修饰的属性表示只能在本类中访问

2.方法公开 针对每个属性提供一对方法，用于存值setter和取值getter

方法名要求 取值 get + 属性名首字母大写 举例 getName()

存值 set + 属性名首字母大写 举例 setHealth()

便于使用者正确使用系统，防止错误修改属性

降低了构建大型系统的风险

提高程序的可重用性

降低程序之间的耦合度(降低耦合度相当于降低紧密连接程度，这样会使我们的程序更加灵活，扩展性更强)

package com.edu.test1;
/**
 *  企鹅类
 * 
 *  封装：将类的信息隐藏在类的内部，不让外部直接访问，而是提供便捷的接口供外界访问
 * 
 *  封装步骤：
 *  1.属性私有  将属性都使用private修饰 被private修饰的属性表示只能在本类中访问
 *  2.方法公开  针对每个属性提供一对方法，用于存值setter和取值getter
 *  方法名要求   取值 get + 属性名首字母大写  举例 getName()
 *              存值 set + 属性名首字母大写 举例 setHealth()

 */
public class Penguin {
    private String name; // 名字 昵称
    private int health; // 健康值
    private String sex; // 性别
    private int love; // 亲密值
    
    
    public void setName(String name) { // 存值 不需要返回值 需要参数 想象银行存钱
        // 这里可以添加其他任何你想要的操作 
        
        this.name = name;
    }
    public String getName() { // 取值不需要参数 需要返回追 想象银行取钱
        return name;
    }
    
    public void  setHealth(int health) {
        if(health >= 0 && health <= 100) {
            this.health = health;
        }else {
            System.out.println("健康值赋值不合理，将使用默认值健康值80");
            this.health = 80;
        }
    }
    
    public int getHealth(){
        return health;
    }   
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getSex() {
        return sex;
    }
    
    public  void setLove(int love) {
        if(love >=0 && love <= 100) {
            this.love = love;
        }else {
            System.out.println("亲密值不合理，将使用默认亲密值60");
            this.love = 60;
        }
    }
    
    public int getLove() {
        return love;
    }
}

package com.edu.test1;
/**
 *  企鹅测试类

 */
public class TestPenguin {
    public static void main(String[] args) {
        Penguin p = new Penguin();

        
        p.setName("大白");
        p.setHealth(-2000);
        p.setLove(-999);
        p.setSex("雌性");
        System.out.println("---------------------------------------------");
        
        System.out.println(p.getName());
        System.out.println(p.getHealth());
        System.out.println(p.getSex());
        System.out.println(p.getLove());
        

        Penguin p1 = new Penguin();
        p1.setName("大黑");
        p1.setHealth(100);
        p1.setLove(100);
        p1.setSex("雄性");
        
    
    }
}
​

2. 访问权限修饰符

2.1 类的访问权限

类的访问权限修饰符

public 表示公开的访问权限 本项目中任何位置都可以使用这个类

默认不写的 表示包级别的访问权限 只能在同一个包中访问

2.2 类成员的访问权限

 

 

package com.edu.test4;
/**
 *  类成员(属性、方法、构造方法)的访问权限修饰符
 *  private     本类
 *  默认不写        本类      本包
 *  protected   本类      本包      子类
 *  public      本类      本包      子类      任何位置
 
 */
public class C {
    private String field1; // 字段 属性 实例变量
            String field2;
    protected String field3;
    public String field4;
    
    private void m1() {
        System.out.println("private修饰的方法m1");
    }
    
    void m2() {
        System.out.println("默认修饰符修饰的方法m2");
    }
    
    protected void m3() {
        System.out.println("ptotected修饰的m3方法");
    }
    
    public void m4() {
        System.out.println("public修饰的m4方法");
    }
    
    public C() {}
    
    C(String field1){
        this.field1 = field1;
    }
    
    protected C(String field1,String field2) {
        this.field1 = field1;
        this.field2 = field2;
    }
    
    public C(String field1,String field2,String field3) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
    }
    
    public static void main(String[] args) {
        C c = new C();
        System.out.println(c.field1); // 红色的方块
        System.out.println(c.field2); // 蓝色的三角
        System.out.println(c.field3); // 黄色的菱形
        System.out.println(c.field4); // 绿色的圆形
        
        c.m1();
        c.m2