封装与继承

封装与继承

封装

概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

原则：隐藏对象的属性和实现细节，仅对外公开借口，并且控制访问级别

实现封装的方法：
1.修改属性的可见性
2.创建共有的getter/setter方法
3.在getter/setter方法中加入属性控制语句

封装的好处：
1.便于使用者正确使用系统，防止错误修改属性
2.有助于系统之间的松耦合，提高系统独立性
3.提高软件的可重用性
4.降低了构建大型系统的风险

练习：使用封装实现企鹅类
使用封装实现电子宠物系统的企鹅类正确输入健康值和亲密度
保证健康值的有效性（0-100），否则取默认值60
保证亲密度的有效性（0-100），否则取默认值60

public class Penguin extends Pet{//继承
    private String name;
    private int health;
    private int love;
    private String sex;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){//getter
        return this.name;
    }
    public  void  setHealth(int health){
        //health的正常范围0-100
        if (health<0 || health>100){
            System.out.println("健康值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            health=60;
//            this.health=60;
//            return;
        }
        this.health=health;
    }
    public int getHealth(){
        return this.health;
    }
    public void setLove(int love){
        if (love<0 || love>100){
            System.out.println("亲密度的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            love=60;
        }
        this.love=love;
    }
    public  int getLove(){
        return this.love;
    }
    public void setSex(String sex){
        this.sex=sex;
    }
    public String getSex(){
        return this.sex;
    }
    public void show(){
        System.out.println("宠物的自白");
        System.out.println("我叫："+name+"健康值："+health+"亲密度："+love+"性别是："+sex);
    }
}

public class TestPenguin {
    public static void main(String[] args) {
        System.out.println("欢迎来到宠物店！");
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要领养的宠物姓名：");
        String name=sc.next();
        System.out.println("请输入要领养的宠物类型：(1、狗狗. 2、企鹅)");
        int type=sc.nextInt();
        if (type==1){
            Dog d=new Dog();
        }else if (type==2){
            Penguin p=new Penguin();
            System.out.println("请输入企鹅的性别：（1、Q仔. 2、Q妹）");
            int sexInt=sc.nextInt();
            System.out.println("请输入企鹅的健康值：（1~100）");
            int health=sc.nextInt();
            System.out.println("请输入企鹅的亲密度：（1~100）");
            int love=sc.nextInt();
            p.setName(name);
            p.setHealth(health);
            p.setLove(love);
            p.setSex(sexInt==1?"Q仔":sexInt==2?"Q妹":null);
            p.show();
        }
    }
}

包

包的作用：
1.允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
2.防止命名冲突，区分名字相同的类
3.有助于实施访问权限控制

命名规范：
1.包名由小写字母组成，不能以圆点开头或结尾
如： package mypackage;
2.包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
如：package net.javagroup.mypackage;
3.包名后续部分依不同机构内部的规范不同而不同
如：package net.javagroup.research.powerproject;

导入包的方法：
1.为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类
格式为： import 包名. 类名

举例：
import java.util.*; //导入java.util包中所有类
import cn.jtest.classandobject.School; //导入指定包中指定类

1. 系统包：java.util
2. 自定义包：cn.jtest.classandobject

注：
1.一个类同时引用了两个来自不同包的同名类
必须通过完整类名来区分

2.每个包都是独立的，顶层包不会包含子包的类
3.package和import的顺序是固定的
package必须位于第一行（忽略注释行）
只允许有一个package语句
其次是import
接着是类的声明

访问修饰符

public：公共的；全工程可见
protected：子类继承的时候使用；包级私有+子类
默认：包级私有；当前类所在的包中可见
private：私有的；只有自己可见

static修饰符：
1. 修饰属性时：全类共用一个存储空间
普通属性：一个对象用一个存储空间
2. 修饰方法时：可以通过类名.方法名（）调用
普通方法可以直接调用静态方法和普通方法
静态方法不能直接调用普通方法
普通方法可以直接调用普通属性和静态属性
静态方法不能直接调用普通属性
3. 静态代码块：
只在第一次访问该类时执行一次，且只执行这一次

类的成员变量包括
类变量（静态变量）
被static修饰的变量
在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

static方法：
1.静态方法：可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
2.实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法

练习2.选民投票
模拟实现选民投票过程：一群选民进行投票，每个选民只允许投一次票，并且当投票总数达到100时，就停止投票

public class Voter {
    public static int voteNum=0;
    public static void vote(){
        voteNum++;
    }
}

public class TestVoter {
    public static void main(String[] args) {
        for (int i = 0; i <= 200; i++) {
            Voter.vote();
            System.out.println("当前投票数为："+Voter.voteNum);
            if (Voter.voteNum==100){
                System.out.println("投票完成");
                break;
            }
        }
    }
}

继承

如何使用继承：
1.编写父类

[访问修饰符] class Pet { 
    //公共的属性和方法
}

2.编写子类，继承父类

[访问修饰符] class Dog extends Pet { 
    //子类特有的属性和方法
}

注：继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类

继承条件下的构造方法：
继承条件下构造方法的调用规则
1.子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法

系统默认调用父类的无参构造方法
2.子类构造方法通过super显式调用父类的有参构造方法

执行父类相应构造方法，而不执行父类无参构造方法
3.子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

继承：
要想让一个类继承另一个类，就要使用到关键字 extends
关键字extends，子类继承父类所有，父类私有的东西也继承了，只是看不到

子类构造方法：
子类创建对象时，会先执行父类的无参构造方法，再执行子类的构造方法

如：

public class Pet {
    private String name;
    private int health;
    private int love;

    public Pet() {
        System.out.println();
    }

    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }
}