Java面向对象基础(2)

1.面向对象三大特性之封装

什么是封装呢？ 封装就是将对象的属性和实现细节进行隐藏，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。（封装就是有选择的暴露）

在下面，就是一个已经封装的学生类

public class Student {
    private String name;//姓名
    private String id;//学号
    //无参构造方法
    public Student() {
    }
    //有参构造方法
    public Student(String name, String id) {
        this.name = name;
        this.id = id;
    }

    //用使用public修饰的set和get方法来对外提供接口
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}

在上面的代码中出现了访问控制修饰符，那么下面就将访问控制修饰符的访问权限范围给展示出来

	同一个类中	同一个包中	不同包中的子类	不同包中的非子类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

2.面向对象三大特性之继承

将某些类具有的一些相同属性和方法进行抽取出来，放到一个类里（父类），让这些被抽取属性和方法的类（子类）去继承父类，这样就可以在不重复书写代码的情况下让子类拥有父类中的属性和方法。

在下面我定义了一个简单的继承结构

//定义父类Animal
public class Animal {
    private String name;//动物品种
    private int age;//动物年龄
    //无参构造和有参构造
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //使用set和get方法对外提供访问接口
    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 void eat(){
        System.out.println("吃东西");
    }
}

//定义子类Cat（让Cat类继承Animal）
public class Cat extends Animal{
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);//super指向父类
    }
    //如果从父类继承的方法（属性）无法满足子类的特定需要，就可以在子类里加上独属于这个子类的方法（属性）
    //例如，在下面定义了独属于Cat类的一个方法---抓老鼠
    public void catchingMice(){
        System.out.println("我是一只猫，我会抓老鼠");
    }
}

//定义子类Tiger（让Tiger类继承Animal）
public class Tiger extends Animal{
    //在继承结构中不能继承父类的构造方法
    public Tiger() {
    }
    public Tiger(String name, int age) {
        super(name, age);
    }
    //在子类中如果需要用父类的方法，但是又与父类不完全相同，就可以选择重写父类中的方法
    //重写完成后就会覆盖从父类继承的方法
    //方法重写的条件：两个类有继承关系，方法名相同，参数列表也相同，访问修饰符的范围不能小于父类
    @Override
    public void eat() {
        //super.eat();
        System.out.println("吃肉");
    }
}

//定义测试类
public class Test {
    public static void main(String[] args) {
        Cat c = new Cat("汤姆",8);//创建Cat类对象
        c.eat();//调用从父类继承来的方法
        c.catchingMice();//调用Cat类独有的方法
        Tiger t = new Tiger("泰哥",22);//创建Tiger类对象
        t.eat();//调用从父类继承的方法
    }
}

3.面向对象三大特性之多态

什么是多态？ 同一个引用类型，使用不同的实例对象而产生不同的操作结果。

在下面就是一个简单的多态实现

需求说明
    宠物饿了，主人需要为宠物喂食，使用多态实现该过程。
    不同宠物吃的东西不一样
    不同宠物吃完东西后恢复健康值不一样
    健康值达到100时，不需要继续喂食

//定义宠物类
public abstract class Pet {
    private String name;//姓名
    private int health;//健康值
    //有参和无参构造
    public Pet() {
    }
    public Pet(String name, int health) {
        this.name = name;
        this.health = health;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    //对生命值加以限制，为100时不在添加生命值
    public void setHealth(int health) {
        if(this.getHealth()==100){
            System.out.println(this.getName()+"很健康，不需要再喂它食物哦");
        } else if (health>100) {
            this.health = 100;//如果传过来的健康值大于100,则直接将宠物的健康值赋值为100
        } else {
            this.health = health;
        }
    }
    //抽象方法eat
    public abstract void eat();
    //展示自己的方法
    public void show(){
        System.out.println("我是"+this.getName()+",健康值为："+this.getHealth());
    }
}

//定义主人类
public class Moster {
    private  String name;
    public Moster() {
    }
    public Moster(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //定义一个喂养宠物的方法
    public void feed(Pet p){
        System.out.println(this.getName()+"喂了"+p.getName());
        p.eat();
    }
}

//定义一个Cat类，让它去继承宠物类
public class Cat extends Pet {
    public Cat() {
    }
    public Cat(String name, int health) {
        super(name, health);
    }
    //子类实现父类中的抽象方法
    @Override
    public void eat() {
        System.out.println("猫猫🐱吃了你喂的小鱼干，健康值增加了");
        this.setHealth(this.getHealth() + 8);//成功吃了一次食物后，就健康值加8
    }
}

//定义狗类，让它去继承宠物类
public class Dog extends Pet{
    public Dog() {
    }
    public Dog(String name, int health) {
        super(name, health);
    }
    //子类实现父类中的抽象方法
    @Override
    public void eat() {
        System.out.println("狗狗吃了你喂的小骨头，健康值增加了");
        this.setHealth(this.getHealth()+5);//成功吃了一次食物后，就健康值加5
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //创建对象
        Pet dog = new Dog("大黄",79);
        Pet cat = new Cat("小橘猫",99);
        Moster moster = new Moster("黎黎");
        //展示宠物的信息
        dog.show();
        cat.show();
        //用创建的主人对象去喂养宠物
        moster.feed(dog);//喂养狗
        moster.feed(cat);//喂养猫
        //喂养完成后再次展示宠物的信息
        dog.show();
        cat.show();
        //再一次去喂养宠物
        moster.feed(dog);//喂养狗
        moster.feed(cat);//喂养猫
        //喂养完成后再次展示宠物的信息
        dog.show();
        cat.show();

    }
}

抽象：abstract关键字

类不需要实例化时，在class关键字前面加上abstract，变为抽象类。

且当方法不需要方法体时，在返回值类型前面加上abstract，变为抽象方法。

抽象类：不能被实例化，抽象类中可以有抽象方法，也可以没有抽象方法

抽象方法：抽象方法没有方法体，但必须在子类中被实现，除非子类也是抽象类

public abstract class Pet{
    //在Pet类中定义了一个抽象方法eat
    public abstract void eat();
}

public class Dog extends Pet{
    //在子类中实现父类中的抽象方法
    @Override
    public void eat() {
        System.out.println("狗狗吃骨头");
    }
}