Java系列教程day10——面向对象的三大特征

day10——面向对象三大特征

提纲：

1、面向对象
2、类和对象
3、方法的重载
4、构造方法
5、this关键字
6、匿名对象
7、作业

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

 

一、封装性

1.1、封装的概念

封装的概念：尽可能的隐藏对象的内部的细节。
  "打包",包起来。为了保护数据的安全性。
    某宝购物，电视机。。。。
    
面向对象中的封装性，不仅仅是对属性进行封装。
一段代码，写了3遍--->封装成一个方法
一堆方法，用了3遍--->封装成工具类：Arrays工具类
。。。
一个方法，一个类，都是一种封装。

1.1.1 private关键字

词义："私有的"。

是一个访问权限修饰符：
  修饰符：public，private，static，final，abstract。。。
  访问权限：在哪个范围内能够访问。
  
作用：限制在本类中才能访问。
private，修饰属性，修饰方法，不能修饰类。
​

1.1.2 getter和setter方法

为了保护属性的数据安全，使用了private访问权限修饰符，限制了只能在类中使用。那么对于外部的对象，如何给属性进行操作？赋值，取值。
使用setter方法，给属性进行赋值。
  set，词义，设置。。
语法格式：
/*
  public void set成员变量名(形式参数){//要给成员变量进行赋值
    this.属性 = 参数名;
  }
  例如：
  public void setAge(int age){
    //.....
    this.age = age;
  }
*/
使用getter方法，获取属性值
  get，词义，获取
    
/*
  public  成员变量的类型 get成员变量名(){
    return this.成语变量名;
  }
  例如：
  public int getAge(){
    return this.age;
  }
*/

1.1.3 类的设计原则

• 成员变量(属性)，私有化(使用private修饰)。添加getter方法和setter方法。
• 公开方法(public修饰)。
• 至少提供无参的构造方法，有参(随意)。

所以说对类中的属性，进行封装的步骤：

step1：使用private关键字，修饰成员变量(属性)。
step2：提供setter方法，用于对属性进行赋值。
  public void set属性名(参数){
    this.属性名 = 参数;
  }
step3：提供getter方法，用于获取属性值。
  public 属性值类型 get属性名(){
    return this.属性名;
  }

属性封装，注意点：

如果一个属性是boolean类型的，get方法的写法：方法名是特殊：isXXX()
private boolean married;//是否已婚
​
//对于boolean类型的get方法：两个状态
public boolean isMarried(){
    return this.married;
}

扩展内容：

数组有长度：表示该数组中存储的元素的个数。
  数组的属性：arr.length
字符串也有长度：表示该字符串中字符的个数。
  "abc"，"hello","he llo"
  字符串的方法：str.length();

二、继承性

2.1、继承的概念

2.2.1 生活中的继承

继承"遗产"。
子承父业。儿子可以继承父亲的东西。

2.2.2 Java中的继承的概念

继承指的是两个类的关系。如果一个类(子类)，继承了另外一个类(父类)。那么子类就可以直接使用父类的非私有化的成员(属性，和方法)。

2.2.3 继承的好处

1、实现代码的重用和扩展。

避免重复的代码：父类写的非私有化的属性和方法，子类不用再写了，直接使用。

类的扩展：思想，子类扩展父类的功能。(父类是人，子类是学生)

2、模拟现实世界的关系。

2.2.4 类的继承

• 关键字：extends，词义：扩展的。描述两个类的关系：子类，父类。
• 被继承的类：父类，根类，超类，基类，SuperClass
• 继承的类：子类，派生类，SubClass

2.2.5 继承的语法

public class FatherClass{
  //属性
  //方法
}
​
public class ChildClass extends FatherClass{
    //新增的属性
    //方法：重写，新增
}

一旦两个类存在了继承的关系，那么：

• 子类可以直接使用父类的非私有化的属性(成员变量)和方法(成员方法)。
• 子类还可以新增自己的属性和方法。
• 子类可以重写父类已有的方法。

2.2.6 什么样的两个类适合继承关系

要两个类，满足is-a 的范式
子类 是一个 特殊的 父类。

eat()，sleep()

name，age，color

狗类：继承动物

eat()，sleep()

name，age

猫类：继承动物

学生，继承人

工人，继承人

小汽车，继承 车

2.2.7 继承的注意点

1、两个类存在了继承关系。
  子类可以使用父类的属性和方法
  但是父类不能使用子类的属性和方法。
2、Java语言的继承是局限性：单继承。
  一个子类，只能有一个父类。
Java语言，不允许多继承，但是可以多层继承。
  一个父类，爷爷类，太爷爷，祖爷爷。。祖宗。。
一个父类是可以有多个子类的。

2.3 子类对象的创建过程

实例化子类对象的过程：

• 1、先调用父类的构造方法
  • 默认调用父类的无参构造方法。

 

• 2、再调用子类的构造方法

 

我们通过代码演示，发现当创建子类对象的时候，默认会先调用父类的构造方法。
调用子类的构造方法中，先调用了父类的构造方法，默认调用的父类的无参构造方法。
1、子类的构造方法中，第一行一定是调用了父类的构造方法。
2、如果没有显示的调用父类的构造方法，那么编译器会自动添加一个：super()，父类的无参构造方法。
3、子类的构造方法中，既可以调用父类的无参构造方法，也可以调用父类的有参构造方法。
4、父类的构造方法：
            无参构造：super();
            有参构造：super(参数);

2.4、super关键字

用法一：super()，指代父类的构造方法。

如果有多个父类的构造方法，那么要靠参数区分。

super()，无参构造

super(参数)，父类的有参构造方法。。

注意点：super()，指代父类的构造方法，一定是位于第一行。同this()指代本类构造方法。

 

方法二：直接访问父类的属性和方法

super.属性--->父类的属性。

super.方法--->父类的方法

 

this.属性

this.方法

2.5、方法的重写

重载(overload)：一个功能方法的多种写法。

同一个类中，方法名必须一致，参数列表必须不同。

重写(override)：继承结构。

概念：在继承结构中，子类将父类已有的方法，重新实现，这叫方法的重写。

如果在子类中，存在方法的重写，那么默认调用的是重写之后的方法。

方法重写的规则：

1、继承结构中。
2、方法的声明，必须和父类的一致。
    方法名必须和父类一致
    参数列表必须和父类一致
    返回值必须和父类一致
3、访问权限，不能比父类更加严格。
4、子类重写的方法，不能抛出比父类更大更多的异常。
/*
         * 1.父类的方法，访问权限：public
         *   子类重写，只能public
         * 2.父类的方法，访问权限：protected
         *   子类重写，protected，public
         * 3.父类的方法，访问权限：default
         *    子类重写，default，protected，public
         * 4.父类的方法，访问权限：private
             对于子类来讲，该方法根本不可见。
         */

2.6、访问权限修饰符

访问权限：就是在哪能访问。通过访问权限修饰符来实现。

作用：限制可见度。

private：私有的。本类中。

默认的：(default)：注意，啥修饰符都不写，就是默认的。本类。同包下可以访问。

protected：受保护的。本类，同包下，不同包(子类使用)

public，没有限制的。

private---> default--->protected--->public

使用原则：

• 修饰类：只能是public和default
• 修饰成员：变量和方法：以上4个修饰符都可以。
• 局部变量，不能使用这些修饰符。

三、多态性

什么是多态

其实就是事物的多种形态。

3.1、对象的多态性

指的是子类对象的多种形态：

子类对象--->看成父类的类型。

子类对象--->看成子类的类型。

 

1、如果声明了一个父类类型的引用(=左边)，创建的是父类的对象(=右边)。
    可以访问父类的属性和方法。（不能访问子类的）
2、如果声明了一个子类类型的引用(=左边)，创建的也是子类的对象(=右边)。
    可以访问父类的属性和方法。
    还可以访问子类的新增。
    以及子类的重写。
    
3、如果声明了一个父类类型的引用(=左边),但是实际上指向了一个子类对象。(=右边)
    可以访问父类的属性和方法。
    以及子类重写的方法。但是不能访问子类的新增。
    

类的实例：new出来的---->对象。

父类：Animal
    属性：name，age
    方法：eat(),sleep()
    
子类：Cat
    新增属性：color
    新增方法：catchMouse()
    重写方法：eat()
子类：Dog
    新增方法：lookDoor()
    重写方法：eat()
​
Animal a1 = new Animal();//a1能够访问的是父类的属性和父类的方法
Cat c1 = new Cat();//c1能够访问name，age，子类新增color。sleep()，子类重写eat，子类新增catchMouse()
​
Dog d1 = new Dog();//d1父类属性：name，age，方法：sleep()，子类重写eat(),子类新增lookDoor()
​
结论：对于子类对象，如果方法存在重写， 那么一定是调用重写之后的方法。

3.2、向上转型和向下转型

向上转型：一个子类对象，看成了父类的类型。（自动转换）

那么只能访问父类的属性和方法，以及子类重写的方法。失去了子类的新增。

 

向下转型：向上转型后，子类对象看成了父类类型，然后再看成子类类型。（强制转换）

可以重新访问子类的新增属性和方法。

向下转型的注意点：不是所有的父类引用都能转成子类类型。向下转型的前提：是一个子类对象先向上转型了，再转回来，那是可以的。但是如果没有向上转型，直接父类对象转为子类类型，报错：ClassCastException。

 

看一个引用，能够访问哪些成员：

看=左边是什么类型的声明：

父类类型：那么能够访问父类中声明属性和方法。

看一个引用，具体执行的方法，是否重写了：

看=右边是什么类型的对象：

如果是父类的对象，执行没有重写的方法，父类的方法。

如果是子类的对象，执行的是重写的方法，子类重写后的方法。

举个栗子：

看戏：国粹，京剧
    京剧大师：--->
        给大家唱戏：
        
    京剧大师：发门票，，要来看戏了。。
        病了，无法登台表演。。。
        
    传承：子承父业。儿子也是唱戏的。
    
        儿子画个花脸上台假装爸爸：装爹。
            只能唱爹的歌。。。重写的方法。
            
        下台卸妆，我是儿子了
            可以唱自己的新歌了。。
    

3.3、instanceof

子类对象向上转型，为父类的类型。自动完成。
但是把一个父类的引用，再转回子类类型。就可能会存在问题。
​
语法：引用 instanceof 类名
    得到的结果：boolean类型
    
对于对象的多态性，如果想向下转型，那么应该先加个逻辑判断。判断该引用指向对象是否是要转换的类型。否则的话，会产生错误：ClassCastException，打断程序的执行。
所以：所有的向下转型之前，都应该使用instanceof进行判断。
    
    向上转型不需要：子类 is a 父类
    

3.4、 对象的多态性的应用

如果一个方法，接收了父类类型作为参数，那么实际上传入父类对象和其他的任意子类对象都可以。如果传入子类对象的话，会发生对象的向上转型。

如果一个方法，返回一个父类类型作为返回值，那么在方法中实际上可以返回任意的子类对象。

 

2.5、多态性概述

多态性：事物的多种形态。

方法：方法的多种形态，指的就是方法的重载。一个功能方法，但是根据参数不同，执行的具体方法也不同。叫做静态多态。程序编译时发生的多态。

对象：对象的多态性，结合方法的重写。一个子类对象，如果看成父类的类型，那么执行的方法就只能父类的以及子类重写的。如果再把该对象向下转型转为子类类型，才可以执行子类的新增方法。

 

1、方法的重载：
    public void getSum(int i,int j){
    
    }
    public void getSum(double d1,double d2){
    
    }
2、对象的多态性：子类对象。看成父类类型(向上转型)，或者看成子类类型(向下转型)。
   方法的重写：
   Animal a = new Animal();//父类类型引用，只能执行父类的方法。
        父类的方法。不是重写的
   Animal a1 = new Cat();//父类类型引用，执行重写后的方法。父类的方法。
        子类重写后的方法。
            
   Cat c1 = (Cat)a1;//子类类型的引用，执行的值重写后的方法，以及子类的新增方法

四、作业

1、创建一个类用于表示三位空间的点：Point。
    私有属性：x坐标，y坐标，z坐标。提供get和set方法。
    再提供构造函数：无参，有参的。
    再提供一个方法，用于打印所有的坐标值。
    再提供一个方法，用于计算两点之间的距离(计算两点之间距离的公式，请自行百度)。
​
    在包含main()的类中，创建两个点对象，调用方法打印坐标值，并求这两个点对象之间的距离。

 

2、多态性练习
    A：创建一个女孩类，私有化属性：姓名，年龄。提供get和set方法。
    B：创建一个宠物类，Pet类，私有化属性name和age，提供get和set方法。
    C：创建子类Cat，Dog，分别继承Pet类。可以新增属性和方法。
​
    D：在女孩类中设计一个方法paly()，表示和宠物玩。该方法可以接收宠物对象作为参数。（提示：利用对象的多态性，将Pet作为参数类型，可以传入任意的子类对象）
​
    E：在包含main()的类中，创建两个女孩对象，创建两个宠物对象，调用play()方法。