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(参数);

Java系列教程day10——面向对象的三大特征_第1张图片


2.4、super关键字

用法一:super(),指代父类的构造方法。

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

super(),无参构造

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

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

 

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

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

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

 

this.属性

this.方法

Java系列教程day10——面向对象的三大特征_第2张图片

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,没有限制的。

Java系列教程day10——面向对象的三大特征_第3张图片

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()
​
结论:对于子类对象,如果方法存在重写, 那么一定是调用重写之后的方法。

Java系列教程day10——面向对象的三大特征_第4张图片


3.2、向上转型和向下转型

向上转型:一个子类对象,看成了父类的类型。(自动转换)

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

 

向下转型:向上转型后,子类对象看成了父类类型,然后再看成子类类型。(强制转换)

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

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

 


看一个引用,能够访问哪些成员:

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

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

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

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

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

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

Java系列教程day10——面向对象的三大特征_第5张图片

举个栗子:

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

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()方法。

你可能感兴趣的:(716466308:资源交流群)