Java中的类、继承与多态网易云课堂笔记

---

一、类和对象

Java程序一般由一个主类和支持这个主类的其他相关类构成，之前已经初步接触和使用到Java类库中的一些基本类（如String等）。要设计一个计算机程序，一种方法是根据问题解决的步骤，将程序组织为一系列的线性代码或函数，然后依次调用或访问即可，如C程序设计语言。而面向对象程序设计语言则是从另一个角度看待计算机程序，其核心是引入了对象概念。

1.用类制造对象

1. 对象是实体，需要被创建可以为我们做事情
2. 类是规范，根据类的定义来创建对象
   对象是表达具体的东西或事件；而类则是定义对象的多有属性。
   例如：狮子、老虎、大象是对象，而他们都属于动物这一类。

2.封装的概念

封装就是：把数据和对数据的操作放在一起因为数据是不外露的，人们需要通过操作获取内部数据。

3.类的定义

一个类由两种东西组成：成员变量和成员函数其中成员变量用来定义对象都有哪些成员组成；成员函数则是表示对象能做些什么。一旦定义了类，我们就可以创建这个类的多个对象，这些对象 都会做那个类定义的动作（函数），但给字具有不同的数据。
（1）创建对象代码

new ATM();//创建一个ATM对象
ATM a=new ATM();//赋值符号前的ATM是类型；后面的ATM是制造的对象

对象变量是对象的管理者
（2）有关对象与类的题目：
如空调遥控器有：打开/关闭空调按钮、调节当前温度、设定空调制冷模式、以及显示当前温度。

public class AirCondition {
   public int temperature=25;//初始化当前空调板温度

    void openorclose(){
        System.out.println("您已打开/关闭空调！");//关闭/打开空调
    }
    void displayTemperature(){
        System.out.println(temperature);//显示当前空调板温度
    }
    void Uptemperature(){
        temperature+=1;//将温度调高1度
        System.out.println(temperature);//显示当前空调温度
    }
    void Downtemperature(){
        temperature-=3;//将温度调低1度
        System.out.println(temperature);//显示当前空调温度
    }
    void Cold(){
        System.out.println("您已选中空调制冷模式！");//空调制冷模式
    }
    public static void main(String args[]){
        new AirCondition();//创建一个AirCondition对象
        AirCondition ac=new AirCondition();//定义一个类型为AirCondition类型的ac对象
        AirCondition ac1=new AirCondition();//定义一个类型为AirCondition类型的ac1对象
        ac.openorclose();//调用打开/关闭动作
        ac.displayTemperature();//调用显示温度动作
        ac.Uptemperature();//调用升温动作
        ac.Downtemperature();//调用降温动作
        ac.displayTemperature();//显示ac当前温度
        ac1.displayTemperature();//显示ac1当前温度
        ac.Cold();//调用制冷模式

    }
}

运行结果截图：

4.成员变量和成员函数

1. 成员变量与成员函数理解
   成员变量的类型可以是任意数据类型，包括简单类型（如整型、浮点型）、数组、类（如String）等，在一个类中，成员变量名是唯一的。类的成员变量定义在所有的方法体之外，因此它的作用域是整个类，即从变量定义开始一直到标识类体结束的}处；成员函数就是表示对象所具有的行为。
2. 调用函数：通过==.==运算符调用某个对象的函数；在成员函数内部直接调用自己(this)的其他函数。
3. 本地变量：定义在函数内部的变量是本地变量；本地变量的生存期和作用域都是函数内部；成员变量的生存期是对象的生存期，作用域是类内部的成员变量

5.对象初始化

成员变量定义初始化：

1. 成员变量在定义的地方就可以给出初始值
2. 没有给出初始值的成员变量会自动获取0值
3. 对象变量的0值表示没有管理任何对象，也可以主动给null值
4. 定义初始化可以调用函数，甚至可以使用已经定义的成员变量

构造函数：

1. 如果一个成员函数的名字和类的名字完全相同，则在创建这个类的每一个对象的时候会自动调用这个函数
2. 这个函数不能有返回值

函数重载：

1. 一个类可以有多个构造函数，只要它们的参数表不同
2. 创建对象的时候给出不同的参数值，就会自动调用不同的构造函数
3. 透过this()还可以调用其他构造函数
4. 一个类里的同名但参数表不同的函数构成了重载关系

6.github类与方法练习题

练习1：设计加油站类和汽车类，加油站提供一个给车加油的方法，参数为剩余汽油数量。每次执行加油方法，汽车的剩余汽油数量都会加 2。

package GasStation;

public class GasStation {
    int remainder=0;//初始化汽车剩余油量为0
    void GasUp(){
        System.out.println("当前汽车剩余油量为"+this.remainder);//打印出汽车当前油量
        remainder+=2;//每加一次油汽车剩余油量就会加2
        System.out.println("为汽车加油，当前汽车剩余油量为："+remainder);//打印出加完油后汽车的剩余油量
    }
    public static void main(String args[]){
        new GasStation();//创建一个GasStaition对象
        GasStation gs=new GasStation();//定义一个类型为GasStation的gs对象
        gs.GasUp();//gs调用GasUp函数

    }
}

运行结果截图：

练习2：智能手机的默认语言为英文，但制造手机时可以将默认语言设置为中文。编写手机类，利用无参构造方法使用默认语言设计，利用有参构造方法修改手机的默认语言。

public class SmartPhone {
    String langurage="English";//设置默认语言（语言初始化）
    void Langurage(){
        this.langurage=langurage;//默认语言为临近的langurage
        System.out.println("Default langrage is："+this.langurage);
    }
    void Langurage(String langurage){
        System.out.println("修改语言为:"+langurage);//修改语言函数
    }
    public static void main(String args[]){
        new SmartPhone();//创建SmartPhone对象
        SmartPhone sp=new SmartPhone();//定义一个类型为SmartPhone的sp对对象
        sp.Langurage();//调用Langurage函数
        sp.Langurage("简体中文");//重载Langurage函数

    }
}

运行结果截图：

练习3：张三去KFC买可乐，商家默认不加冰块。但是张三可以要求加 3 个冰块。请利用有参构造方法实现上述功能。

public class FastFood {
    int number;
    void Cola(){
        this.number=0;
        System.out.println("KFC店员默认给顾客张三可乐中加"+number+"个冰块。");
    }
    void Cola(int number){
        System.out.println("张三让KFC店员为他在可乐中加"+number+"个冰块。");
    }
    public static void main(String args[]){
        new FastFood();
        FastFood ff=new FastFood();
        ff.Cola();
        ff.Cola(3);

    }
}

运行结果截图：

练习4：创建教师类，类中有姓名、性别和年龄三个属性，在构造方法中使用 this 关键字分别为这三个成员属性赋值。

public class Teacher {
    String name;//定义姓名变量
    String sex;//定义性别变量
    int age;//定义年龄变量
    void Name(String name){
        this.name=name;//获取姓名变量
        System.out.println("教师姓名为："+name);//输出教师姓名
    }
    void Sex(String sex){
        this.sex=sex;//this后的sex是Teacher类中的变量；而赋值号后面的sex则是方法内的量
        System.out.println("教师性别为："+sex);//输出教师性别
    }
    void Age(int age){
        this.age=age;//获取教师年龄
        System.out.println("教师年龄为："+age);//输出教师年龄
    }
    public static void main(String args[]){
        new Teacher();//创建Teacher对象
        Teacher t=new Teacher();//定义一个类型为Teacher的t变量
        t.Name("张虹");//打印出教师姓名
        t.Sex("女");//打印出教师性别
        t.Age(35);//打印出教师年龄

    }
}

运行结果截图：

练习5：一只大熊猫，长 1.3 米，重 90千克。在自定义方法中使用this关键字调用类的成员变量并在控制台输出这只大熊猫的信息。

public class Panda {
    double hight;//定义大熊猫长度变量
    double wight;//定义大熊猫体重变量
    void getHight(double hight){
        this.hight=hight;//定义大熊猫长度
        System.out.println("大熊猫的长度为："+hight+"米。");
    }
    void getWight(double wight){
        this.wight=wight;//定义大熊猫的体重
        System.out.println("大熊猫的体重为："+wight+"千克");
    }
    public static void main(String args[]){
        new Panda();//定义Panda对象
        Panda p=new Panda();//定义类型为Panda的p变量
        p.getHight(1.3);//定义大熊猫长度并调用getHight方法
        p.getWight(90);//定义大熊猫重量并调用getWight方法
    }
}

运行代码截图：

练习6：创建信用卡类，有两个成员变量分别是卡号和密码，如果用户开户时没有设置初始密码，则使用"123456"作为默认密码。设计两个不同的构造方法，分别用于用户设置密码和用户未设置密码两种构造场景。

public class CreditCard {
    String name;//定义姓名变量
    String password="123456";//初始化密码变量
    void getName(String name){
        this.name=name;//定义用户账号
        System.out.println("用户账号为："+name);
    }
    void getPassword(){
        System.out.println("用户密码为："+password);
    }
    void getPassword(String password){
        this.password=password;
        System.out.println("用户密码为："+password);
    }
    void line(){
        System.out.println("--------------------------");
    }
    public static void main(String args[]){
        new CreditCard();//创建CreditCard对象
        CreditCard c=new CreditCard();//创建CreditCard类型的对象c
        CreditCard c1=new CreditCard();//创建CreditCard类型的对象c1
        c.getName("张虹");//c调用getName函数
        c.getPassword("210718");//c的密码为该密码
        c.line();//划分线
        c1.getName("张悦");//c1调用getName函数
        c1.getPassword();//c1的密码
    }
}

运行结果截图：

二、继承与多态

1.继承的定义

继承是一种基于已有类创建新类的机制，利用继承可以先创建一个具有广泛意义的类，然后通过派生创建新类，并添加一些特殊的属性和行为。被继承的类成为父类，其派生得到的类成为子类。例如：我们做一道简单的菜都是以：洗菜、切菜、倒油、翻炒这四个步骤，按照这四个步骤就能做出：宫保鸡丁、麻婆豆腐、糖醋里脊等饭菜。我们可以先写一个做菜步骤的类，然后在吧所有菜需要的不同食材放到不同的类中，然后继承做菜步骤这个类。

class 父类{
......
}
class 子类 extends 父类{
......
}

2.this与super

super：引用当前对象的父类成员
this：指向当前类的引用。
具体可参考这位博主的文章： Java中this和super的用法总结

3.继承的特性

1. 子类不继承父类的private属性和方法
2. 子类可以对父类进行扩展（extends），拥有自己的属性和方法
3. 子类是不继承父类的构造器（构造方法或构造函数）的，它只是调用（隐式或显式）。如果服了的构造器带有参数，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表
4. 如果父类构造器没有参数，则在子类的构造器中不需要使用super关键字调用父类构造器，系统会自动调用父类的无参构造器

4.不同访问属性的父类成员在子类中的访问属性

父类成员访问属性	在父类中的含义	在子类中的含义
public	对所有人开放	对所有人开放
protected	只有包内其它类、自己和子类可以访问	只有包内其它类、自己和子类可以访问
缺省	只有包内其它类可以访问	如果子类与父类在同一个包内：只有包内其它类可以访问否则：相当于private，不能访问
private	只有自己可以访问	不能访问

5.多态的定义

简单来说多态就是一个名称可以对应多种不同的实现方法,例如：我国北宋时期的王维他既是政治家也是诗人。这就是多态。

6.github类与方法练习题

练习1：创建银行卡类，并设计银行卡的两个子类∶ 储蓄卡与信用卡。

package Bank;

class Card{//父类为银行卡类（子类卡所具备的所有相同动作）
    String cardtype;//定义一个卡类型的变量
    public void display(){
        System.out.println("欢迎办理银行卡业务！");//所有卡都要输出这句话
    }
    public void CardType(String cardtype){
        this.cardtype=cardtype;//选取银行卡的类型
        System.out.println("您已选择办理"+cardtype+"业务。");
    }
    public void Line(){
        System.out.println("------------------------------");//分隔线
    }
}

class SaveCard extends Card{//储蓄卡继承银行卡这个类

}

class CreditCard extends Card{//信用卡继承银行卡这个类
    void cc(){//信用卡比银行卡多的提示功能
        System.out.println("温馨提示：请勿刷爆卡。");
    }

}

public class Bank {
    public static void main(String args[]){
        SaveCard sc=new SaveCard();//创建SaveCard类型的sc对象
        sc.display();//sc调用display函数
        sc.CardType("储蓄卡");//sc调用CardType函数
        sc.Line();//sc调用Line函数

        CreditCard cc=new CreditCard();//创建CreditCard类型cc对象
        cc.display();//cc调用display函数
        cc.CardType("信用卡");//cc调用CardType函数
        cc.cc();//cc调用信用卡自有的函数
    }

}

运行结果截图：

练习2：设计火车类和高铁类，高铁类继承火车类，不管火车类的行进速度是多少，高铁的行进速度永远是火车的二倍。

package Train;
import java.util.Scanner;

class CommentTrain{
    double kilometer;
    public void Display(double kilometer){
        this.kilometer=kilometer;
        System.out.println("普通火车的速度是："+kilometer+"km/h.");
    }
}

class HighwayTrain extends CommentTrain{
    void display(double kilometer){
        this.kilometer=kilometer;
        System.out. println("高铁的速度是："+(2*kilometer)+"km/h.");
    }
}

public class Train {
    public static void main(String args[]){
        System.out.println("请输入火车速度：");
        Scanner sc=new Scanner(System.in);
        double kilometer=sc.nextDouble();
        new HighwayTrain();
        HighwayTrain ht=new HighwayTrain();
        ht.Display(kilometer);
        ht.display(kilometer);

    }
}

运行代码截图：

练习3：设计人类，有二个自我介绍的方法，输出"我是 XXX";设计博士类，继承人类，博士类自我介绍时输出"我是XXX 博士"。

package Introdction;
import java.util.Scanner;

class Person{
    public void display(String name){
        System.out.println("我是"+name);
    }
}

public class Doctor extends Person{
    public static void main(String args[]){
        Person p=new Person();
        Scanner sc=new Scanner(System.in);
        String name=sc.nextLine();
        p.display(name);
        System.out.println("我是"+name+"博士");

    }
}

运行结果截图：

练习4：使用方法的重载描述所有的超市都支持现金付款，但大型商超还支持刷卡付款。

public class Shoppiing {
    //定义一个方法
    public void display(String d){
        System.out.println("小型超市支持："+d+"支付方式。");
    }

    public void display(String d,String e){
        System.out.println("大型商超支持："+d+"、"+e+"支付方式。");
    }

    public static void main(String args[]){
        new Shoppiing();
        Shoppiing sp=new Shoppiing();
        sp.display("现金");
        sp.display("现金支付","刷卡");
    }
}

运行代码截图：

引用

【1】网易云课堂Java进阶
【2】Java程序设计（第2版）清华大学出版社
【3】github开源题目
注：本篇代码题目大部分为自己编写，如有问题会及时修正。