Java基础学习第十四天（封装、继承、多态）

一、封装

1、面向对象三大特征：封装、继承、多态

2、权限修饰符：权限修饰符就是控制变量可见范围的。
public：公共的，public修饰的成员变量或者方法任何人都可以直接访问。
private：私有的，private修饰的成员变量或者方法只能在本类中进行直接访问。

3、封装的步骤
① 使用private修饰需要被封装的属性。
② 提供一个公共的方法设置或者获取该私有的成员属性。
set属性名(); [设置属性]
get属性名(); [获取属性]

4、疑问： 封装一定要提供get或者set方法吗？
不一定， 根据需求而定的。

5、规范 ： 在现实开发中一般实体类的所有成员属性（成员变量）都要封装起来。
实体类：实体类就是用于描述一类事物的就称作为实体类。

6、封装的好处：提高数据的安全性、操作简单、隐藏了实现

 class MyMember{    
    public  String name; //名字
    private String sex; //性别
    public  int salary; //薪水        

    //定义一个公共的方法设置sex属性
    public void setSex(String s){
        if (s.equals("男")||s.equals("女")){ //注意：如果比较两个字符串的内容是否一致，不要使用==比较，使用equals方法。
            sex = s;
        }else{
            //默认是男
            sex = "男";
        }
    }
    //定义一个公共的方法获取sex属性
    public String getSex(){
        return sex;
    }

    //聊天
    public void talk(){
        System.out.println(name+"聊得非常开心");
    }
}

class Demo14.1{
    public static void main(String[] args){
        MyMember m = new MyMember();
        m.name="李四";
        m.setSex("女");
        m.salary  = 8000;
        System.out.println("姓名："+ m.name+" 性别："+ m.getSex()+" 薪水："+ m.salary);
    }
}

7、需求： 使用java类描述一个计算器类，计算器具备操作数1， 操作数2 、操作符三个公共的属性，还具备计算的功能行为。要求： 不能直接对操作数1，操作数2，运算符这些属性进行直接的赋值，要封装起来。(+ - * / )

//计算器类
class Calculator{
    private int num1; //操作数1
    private int num2;  //操作数2 
    private char option ; //运算符 

    //提供公共的方法设置属性值....                  
    public void initCalculator(int n1 , int n2 , char op){ //初始化计算器
        num1 = n1;
        num2 = n2;
        if(op=='+'||op=='-'||op=='*'||op=='/'){
            option = op;
        }else{
            option = '+';   
        }   
    }
    //计算的功能
    public void calculate(){
        switch(option){
            case '+':
                System.out.println("做加法运算,结果是："+(num1+num2));
                break;
            case '-':
                System.out.println("做减法运算,结果是："+(num1-num2));
                break;
            case '*':
                System.out.println("做乘法运算,结果是："+(num1*num2));
                break;
            case '/':
                System.out.println("做除法运算,结果是："+(num1/num2));
                break;
        }
    }
}
class Demo14.2{
    public static void main(String[] args){
        //创建了一个计算器对象
        Calculator c = new Calculator();
        //设置属性值
        c.initCalculator(1,2,'+');
        //调用计算器的计算功能
        c.calculate();
    }
}

二、继承

1、类与类之间常见关系（整体与部分的关系）

//球员类
class Player{   
    int num; //编码
    String name;
    public Player(int num , String name){
        this.num = num;
        this.name = name;
    }
    public void run(){
        System.out.println(name+"开跑...");
    }
}
//球队类
class Team{
    String name;  //球队的名字
    Player p1;  //球员1 
    Player p2;  //球员2
    Player p3;  //球员3
    public  Team(String name,Player p1,Player p2,Player p3){
        this.name = name;
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }   
    //开始比赛
    public void startGame(){
        System.out.println(name+"开赛啦！！");
    }
}
class Demo14.3{
    public static void main(String[] args){
        Player p1 = new Player(12,"梅西");
        Player p2 = new Player(7,"C罗");
        Player p3 = new Player(11,"内马尔");
        //球队
        Team t = new Team("恒大",p1,p2,p3);
        t.startGame();      
        System.out.println("名字："+ t.p2.name);
    }
}

2、继承：继承是通过关键字extends体现的。

3、继承的格式

class 类名1 extends 类名2{

    }

4、继承要注意的事项：
① 不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承
② 父类私有的成员不能被继承。
③ 父类的构造函数不能被继承
④ 创建子类对象时默认会先调用父类无参的构造函数

扫描二维码关注公众号，回复： 186792 查看本文章

//人类 
class Person{
    String name;
    private int age;
    public  Person(String name){
        this.name = name;
    }
    public Person(){
        System.out.println("Person类的构造方法被调用了....");
    }
    public void eat(){
        System.out.println(name+"在吃饭...");
    }
}
//学生类
class Student extends Person {  // Student称作为Person类的子类，Person类就称作为Student的父类(超类、基类)
    int num; //学号
    public Student(){
        System.out.println("Student类的构造方法被调用了....");
    }
    public void study(){
        System.out.println(name+"好好学习!");
    }   
}
class Demo14.4{
    public static void main(String[] args){
        Student s = new Student();      
        s.name = "狗娃";
        System.out.println("名字："+ s.name);
        s.eat();
    }
}

5、调用父类的构造方法是可以初始化从父类继承下去的属性的。

class Fu{   
    int x = 10;
    String name;
    public Fu(String name){
        this.name = name;
        System.out.println("Fu类d带参的构造方法...");
    }
    public Fu(){
        System.out.println("Fu类无参的构造方法...");
    }
}
class Zi extends Fu{
    int x = 20;
    public Zi(String name){
        super(name); //指定调用父类一个参数的构造函数。
    }
    public void print(){
        System.out.println("x1 = "+ x);
    }

}
class Demo14.5{
    public static void main(String[] args){
        Zi z = new Zi("大头儿子"); 
        System.out.println("name= "+z.name);
    }
}

6、super关键字
① super关键字代表了父类空间的引用。
② super关键字的作用
◆ 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
◆ 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。
③ super关键字调用父类构造方法要注意的事项
◆ 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
◆ super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
◆ super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。
④ super关键字与this关键字的区别
◆ 代表的事物不一致。
super关键字代表的是父类空间的引用。 this关键字代表的是所属函数的调用者对象。
◆ 使用前提不一致。
super关键字必须要有继承关系才能使用。this关键字不需要存在继承关系也可使用。
◆ 调用构造函数的区别
super关键字是调用父类的构造函数。this关键字是调用本类的构造函数。

7、方法的重写
① 方法重写的前提： 必须要存在继承的关系。
② 方法的重写：子父类出了同名的函数，这个我们就称作为方法的重写。
③ 什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。
④ 方法重写要注意的事项：
◆ 方法重写时， 方法名与形参列表必须一致。
◆ 方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
◆ 方法重写时，子类的返回值类型必须要小于或者等于父类的返回值类型。
◆ 方法重写时，子类抛出的异常类型要小于或者等于父类抛出的异常类型。
Exception(最坏)、RuntimeException(小坏)
⑤ 方法重载的要求
◆ 函数名要一致。
◆ 形参列表不一致（形参的个数或形参的类型不一致）
◆ 与返回值类型无关。

class Animal{}  //大的数据类型 
class Fish extends Animal{}  //小的数据类型
class Fu{
    String name;
    public Fu(String name){
        this.name = name;
    }
    public Animal eat() throws RuntimeException {
        System.out.println(name+"吃番薯...");
        return new Animal();
    }
}
class Zi extends Fu{
    String num; 
    public Zi(String name){
        super(name);//指定调用父类带参的构造方法
    }
    //重写父类的eat方法
    public Animal eat() throws Exception{
        System.out.println("吃点开胃菜..");
        System.out.println("喝点汤....");
        System.out.println("吃点龙虾....");
        System.out.println("吃青菜....");
        System.out.println("喝两杯....");
        System.out.println("吃点甜品...."); 
        return new Animal();
    }
}
class Demo14.6{
    public static void main(String[] args){
        Zi z = new Zi("大头儿子");
        z.eat();    
    }
}

8、instanceof关键字
① 作用：判断一个对象是否属于指定的类别。
② 使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。
③ 使用格式：对象 instanceof 类别
④ 作用： 多态。一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的。

class Animal{
    String name;
    String color;
    public Animal(String name, String color){
        this.name = name;
        this.color = color;
    }
}
//狗是属于动物中一种
class Dog extends Animal {
    public Dog(String name,String color){
        super(name,color); //指定调用父类两个 参数的构造函数。
    }
    public void bite(){
        System.out.println(name+"咬人!!");
    }
}
//老鼠也是属于动物中一种
class Mouse extends Animal{ 
    public Mouse(String name,String color){
        super(name,color);
    }   
    public void dig(){
        System.out.println(name+"打洞..");
    }
}
class Demo14.7{
    public static void main(String[] args){
        Dog d = new Dog("哈士奇","白色");
        System.out.println("狗是狗类吗？"+(d instanceof Dog));//true
        System.out.println("狗是动物类吗？"+(d instanceof Animal));//true
        System.out.println("狗是老鼠类吗？"+ (d instanceof Mouse));=//报错
        Animal a = new Animal("狗娃","黄色"); 
        System.out.println("动物都是狗吗？"+ (a instanceof Dog));//false
    }
}

9、final关键字
final关键字的用法：
① final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
② fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
③ final关键字修饰一个函数的时候，该函数不能被重写。
④ final关键字修饰一个类的时候，该类不能被继承。

常量的修饰符一般为： public static final

//圆形
class Circle{
    double r; //半径
    public static final double PI = 3.14; //固定不变的
    public Circle(double r){
        this.r = r;
    }
    //计算面积
    public final void getArea(){
        System.out.println("圆形的面积是："+r*r*PI);
    }
}
class Demo14.8 extends Circle{  
    public Demo14.8(double r){
        super(r);
    }
    public static void main(String[] args){
        final Circle c = new Circle(4.0);
        test(c);

        Demo14.8 c = new Demo14.8(4.0);
        c.getArea();
    }   
    public static void test(Circle c){
        c = new Circle(5.0);  //c变量又重新指向了新的对象。
        c.getArea();
    }
}

三、多态

1、多态：一个对象具备多种形态(父类的引用类型变量指向了子类的对象)、或者是接口 的引用类型变量指向了接口实现类的对象)

2、多态的前提：必须存在继承或者实现关系。

3、多态要注意的细节
① 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量
② 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数
③ 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数
④ 多态情况下，不能访问子类特有的成员
①②③ 总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。

4、编译看左边，运行不一定看右边。
编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。

//动物类
abstract class Animal{
    String name;
    String  color = "动物色";
    public Animal(String name){
        this.name = name;
    }
    public abstract void run();
    public static void eat(){
        System.out.println("吃得很开心..");
    }
}
//老鼠
class  Mouse extends Animal{
    String color = "黑色";
    public Mouse(String name){
        super(name);
    }   
    public void run(){
        System.out.println(name+"四条腿慢慢的走!");
    }
    public static void eat(){
        System.out.println("老鼠在偷吃..");
    }
    //老鼠特有方法---打洞
    public void dig(){
        System.out.println("老鼠在打洞..");
    }
}
class Fish extends Animal {
    public Fish(String name){
        super(name);
    }   
    public  void run(){
        System.out.println(name+"摇摇尾巴游..");
    }
}
class Demo14.9{
    public static void main(String[] args){
        //多态：父类的引用类型变量指向子类的对象
        Animal a = new Mouse("老鼠");
        System.out.println(a.color);//动物色
        a.dig();
        //a.eat();
    }   
}

5、多态的应用
① 多态用于形参类型的时候，可以接收更多类型的数据 。
② 多态用于返回值类型的时候，可以返回更多类型的数据。

6、多态的好处： 提高了代码的拓展性。

//需求： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。

//图形类
abstract class MyShape{
    public abstract void getArea();
    public abstract void getLength();   
}
class Circle extends MyShape{//圆形
    public static final double PI = 3.14;
    double r;
    public Circle(double r){
        this.r =r ; 
    }
    public void getArea(){
        System.out.println("圆形的面积："+ PI*r*r);
    }
    public void getLength(){
        System.out.println("圆形的周长："+ 2*PI*r);
    }
}
class Rect extends MyShape{//矩形
    int width;
    int height;
    public Rect(int width , int height){
        this.width = width;
        this.height = height;
    }
    public void getArea(){
        System.out.println("矩形的面积："+ width*height);
    }
    public void getLength(){
        System.out.println("矩形的周长："+ 2*(width+height));
    }
}
class Demo14.10{
    public static void main(String[] args){
        Circle c = new Circle(4.0);
        print(c);
        Rect r = new Rect(3,4);
        print(r);

        MyShape m = getShape(0); //调用了使用多态的方法，定义的变量类型要与返回值类型一致。
        m.getArea();
        m.getLength();
    }
    //需求1：定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
    public static void print(MyShape s){ 
        s.getArea();
        s.getLength();
    }
    // 需求2：定义一个函数可以返回任意类型的图形对象。
    public static MyShape getShape(int i){
        if (i==0){
            return new Circle(4.0);
        }else{
            return new Rect(3,4);
        }
    }
}

7、目前多态情况下不能访问子类特有的成员，如果需要访问子类特有的成员，那么需要进行类型强制转换。
类型转换最场景的问题： java.lang.ClassCastException。 强制类型转换失败。

//动物类
abstract class Animal{
    String name;
    public Animal(String name){
        this.name = name;
    }
    public abstract void run();
}
//老鼠
class Mouse extends Animal{
    public Mouse(String name){
        super(name);
    }   
    public  void run(){
        System.out.println(name+"四条腿慢慢的走!");
    }
    //老鼠特有方法---打洞
    public void dig(){
        System.out.println("老鼠在打洞..");
    }
}
//鱼
class Fish extends Animal{
    public Fish(String name){
        super(name);
    }
    public void run(){
        System.out.println(name+"摇摇尾巴游啊游 !");
    }
    //吹泡泡
    public void bubble(){
        System.out.println(name+"吹泡泡...!");
    }
}
class Demo14.11{
    public static void main(String[] args){
        Animal a = new Mouse("老鼠");  //多态
        //调用子类特有的方法
        Mouse m  = (Mouse)a;  //强制类型转换
        m.dig();

        Mouse m = new Mouse("米老鼠");
        Fish f = new Fish("草鱼");
        print(f);
    }
    //需求： 定义一个函数可以接收任意类型的动物对象，在函数内部要调用到动物特有的方法。
    public static void print(Animal a){
        if(a instanceof Fish){
            Fish f = (Fish)a;
            f.bubble();
        }else if(a instanceof Mouse){
            Mouse m = (Mouse)a;
            m.dig();
        }
    }
}

8、实现关系下的多态：接口 变量 = new 接口实现类的对象

interface Dao{  //接口的方法全部都是非静态的方法
    public void add();
    public void delete();
}
//接口的实现类
class UserDao implements Dao{   
    public void add(){
        System.out.println("添加员工成功！！");
    }
    public void delete(){
        System.out.println("删除员工成功！！");
    }
}
class Demo14.12{
    public static void main(String[] args){
        //实现关系下的多态
        Dao d = new UserDao(); //接口的引用类型变量指向了接口实现类的对象
        d.add();
    }
}