Chp5-封装 继承和方法重写

封装

面向对象的核心思想：封装、继承、多态

概念

是一种屏障，作用为保护对象数据不被外加任意访问

步骤

1. 属性私有化

 private 数据类型 属性名;

	含义	作用范围
public	公开的，公共的	任意位置都可以访问
private	私有的	本类内部都可以访问

可以选择性的对属性进行私有化操作，但是通常情况下所有属性都应该参与私有化

2. 提供取值赋值对应的getter和setter方法
   ------ getter方法-取值

 public 数据类型 getXxx(){
         return 属性名;
     }
     注：Xxx对应的是属性名，首字母大写

• 有返回值，无参数
• 返回值类型与对应属性类型一致
• 如果获取的属性类型为布尔类型，则方法名为isXxx
  ------setter方法-赋值

 public void setXxx(数据类型 属性名){
         this.属性名=属性名;
     }
     注：Xxx对应的是属性名，首字母大写

可以选择性的为私有属性添加getter和setter方法，但是通常情况下都应该具备相应方法

package com.by.entity;

/**
 * 银行卡: 卡号  密码  余额
 */
public class BankCard {
    private String cardID;
    private String password;
    private double balance;

    //取值
    public String getCardID(){
        return cardID;
    }
    //赋值
    public void setCardID(String cardID){
        this.cardID = cardID;
    }
    //密码-取值
    public String getPassword(){
        return password;
    }

    //赋值
    public void setPassword(String password) {
        this.password = password;
    }

    //余额-取值
    public double getBalance() {
        return balance;
    }

    //赋值
    public void setBalance(double balance) {
        this.balance = balance;
    }

    public BankCard(){}
    public BankCard(String cardID,String password,double balance){
        this.cardID = cardID;
        this.password = password;
        this.balance = balance;
    }
}

使用

取值:对象名.getXxx() | 对象名.isXxx()
赋值:对象名.setXxx(实参);

注：Xxx对应的是属性名，首字母大写

package com.by.test;

import com.by.entity.BankCard;

public class TestBankcard {
    public static void main(String[] args) {
        BankCard bc = new BankCard("6288888888888888", "411381", 100.0);
        //赋值
        bc.setCardID("6277777777777777");
        bc.setPassword("123456");
        bc.setBalance(10000.0);
        //查看属性值
        System.out.println(bc.getCardID());
        System.out.println(bc.getPassword());
        System.out.println(bc.getBalance());

    }
}

今日掌握

1. 封装的步骤
2. getter和setter方法的区别
3. 封装后属性的使用

Chp6-继承

概念

将子类之间的共性进行抽取生成父类，在继承关系下，子类能够直接拥有父亲可被继承的内容

继承的作用之一就是解决子类之间的代码冗余问题

语法

public class 子类类名 extends 父类类名{
    
}

package com.by.entity;
/**
 动物类-父类
 */
public class Animal {
    //名字  年龄  性别
    public String name;
    public int age;
    public boolean sex;

    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class Dog extends Animal{

}

public class Cat extends Animal{

}

package com.by.test;

import com.by.entity.Cat;
import com.by.entity.Dog;

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "小黑";
        d.eat();
        d.sleep();
        Cat c = new Cat();
        c.eat();
        c.sleep();

    }
}

规则

1. 继承双方必须满足is a的关系结构
2. 一个子类只能有一个直接父类，一个父类可以拥有多个直接子类**（单继承）**
3. 一个子类在身为子类的同时也可以是其他类的父类
4. 子类可以拥有独有内容
5. 子类可以继承拥有所有父类所有可被继承的内容
6. 父类无法使用和访问子类的独有内容
7. 父类的私有内容子类无法直接使用
8. 父类的构造子类

子类内存结构

• 子类内存由父类和子类独有内容组成

父类封装

package com.by.entity;

/**
 动物类-父类
 */
public class Animal {
    //名字  年龄  性别
    private String name;
    private int age;
    private boolean sex;

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }

    private void method(){

    }
}

package com.by.test;

import com.by.entity.Dog;

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.setName("小黑");
        System.out.println(d.getName());

    }

}

方法重写

• 子类对从父类继承过来的方法进行方法体的重新书写，简称方法重写，也称方法覆盖

规则

1. 建立在继承关系之上
2. 方法名、参数列表、返回值类型必须与父类保持一致
3. 访问修饰符与父类相同或更宽
4. 不允许抛出比父类更大或更多的异常

使用

1. 子类重写之后，优先执行子类重写内容
2. 父类的作用

• 解决子类之间的冗余问题
• 强制约束子类必须拥有某些内容

访问修饰符

	本类	同包	非同包子类	非同包非子类
private-私有的	√
default-默认的	√	√
protected-受保护的	√	√	√
public-公共的,公开的	√	√	√	√

1. 只有default和public可以修饰类
2. default 无法显示声明
3. 以上四个都可以修饰属性、方法、构造
4. 以上四个都不能修饰局部变量

有继承关系的对象的创建过程

1. 给父子类属性分配空间，赋默认值
2. 给父类属性赋初始值
3. 执行父类构造再次赋值
4. 给子类属性赋初始值
5. 执行子类构造再次赋值

总结：先构建父类内容，才能构建子类内容

super关键字

• 代表父类对象

super关键字

作用为调用父类构造内容

使用

1. 必须雪灾子类构造方法有效代码第一行
2. 和this（）无法同时显示存在
3. 通过实参列表决定调用的是哪个父类构造
4. 子类构造第一行默认存在无参的super（）

子类有参构造写法：

public 子类类名(父类的形参列表,自己独有的属性){
    //先调用super()给父类声明属性赋值
    super(对应的父类的形参);
    //再this.给自己的独有属性赋值
    this.自己的属性名=属性名;
}

 package com.by.entity;

/**
 动物类-父类
 */
public class Animal {
    //名字  年龄  性别
    private String name;
    private int age;
    private boolean sex;

    public Animal(){}
    public Animal(String name, int age, boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
//省略getter\setter
}

```java
 public class Cat extends Animal{
    private String color;

    public Cat(){}
    public Cat(String name, int age, boolean sex,String color){
       //先调用super()给父类声明属性赋值
        super(name, age, sex);
        //再this.给自己的独有属性赋值
        this.color = color;
    }
}

super.

• 用来指明调用父类的属性或方法

super.属性名
super.方法名(实参)

public class Dog extends Animal{
        //从animal继承过来了名字,年龄,性别,吃饭(),睡觉()

    //重写父类方法
    public void eat(){
        //调用父类的eat方法
        super.eat();
        System.out.println("狗吃大骨头");
    }
}

今日掌握

1. 继承的语法
2. 继承的规则
3. 方法重写的规则
4. 访问修饰符及其作用范围
5. 有继承关系的对象创建过程
6. super（）在子类构造中的运用