Java第七章总结

淩亂°似流年 2023-09-26 19:45 40阅读 0赞

#### 文章目录 ####

*  序章
 *  类的继承
 *   *  继承关系的定义
     *  继承关系的好处
     *  Object类
     *  对象类型的转换
     *  方法重载
     *  final关键字
     *  instanceof关键字
     *  多态
 *  抽象类
 *  接口
 *  结尾

## 序章 ##

本章节的内容基本上是类与类之间的关系。

## 类的继承 ##

### 继承关系的定义 ###

继承在人类个体之间说的是物质的继承，那么在Java中类与类之间的继承也类似于此，类在继承关系中分为两种，一种是**父类**，属于是**被继承类**，一种是**子类**，属于是**继承类**，如果某一个类继承了另一个类，那么该类就是子类，被继承的类就是父类。

Java中一个类继承另一个类，需要使用到**关键字extends**。  
**使用格式如下**

class Child extends Parent(){
        	//类Child 继承于类 Parent
    }

**注意，在Java中只支持单继承，一个子类只能拥有一个父类，但是一个父类可以拥有多个子类。不允许多继承，但是允许多重继承。**

**错误代码**

class C extends A,B{
        
    }

![在这里插入图片描述][8b92b36a17c84416a9959081532e8090.png]

**允许多重继承**

class A{
        }
    class B extends A{
        }
    class C extends B{
        
    }

![在这里插入图片描述][1558318057994258b8a9b494fccbfa9d.png]

### 继承关系的好处 ###

在两个类的关系呈包含与被包含的关系时，使用关键字形成继承关系之后，那么子类就可以直接使用父类中已经创建好的属性与方法，减少重复的代码段，提高代码的复用性。

**例如：子类对象调用父类方法**

class animal{
        
        public void eat(){
        
            System.out.println("进食");
        }
    }
    
    class cat extends animal{
        
    }
    
    public class Demo_1 {
        
        public static void main(String[] args) {
        
            cat feline = new cat();
            feline.eat();
        }
    }

![在这里插入图片描述][e6233dd661724287a88d469833986258.png]

**子类继承父类后，在创建子类对象的同时，会先调用父类的构造方法。**

class Pearent{
        
        public Pearent(){
        
            System.out.println("调用父类的构造方法");
        }
    }
    
    class Child extends Pearent{
        
        public Child() {
        
            System.out.println("调用子类的构造方法");
        }
    }
    
    public class Demo {
        
        public static void main(String[] args) {
        
            new Child();
        }
    }

![在这里插入图片描述][fc26152bef8a466184765f31bdede10c.png]

### Object类 ###

Object类是Java中的顶级父类，在Java中所有类都直接或间接的继承与Object类，它是所有类的父类。

在Object类中有很多Java已经帮我们定义好了的方法，下面就简单介绍几个。

**1.toString() 方法**

toString() 方法的功能是 将一个对象返回为字符串形式，它会返回一个String类型的实例。

调用方式

类名.toString();

class student{
        
        String name;
        int age;
    
        public student() {
        
        }
    
        public student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    	
    	//重写了父类中的toString()方法
        @Override
        public String toString(){
        
            return "姓名："+this.name+"，年龄："+this.age;
        }
    }
    
    public class Demo_3 {
        
        public static void main(String[] args) {
        
            student s1=new student("小明",18);
            System.out.println(s1.toString());
        }
    }

![在这里插入图片描述][47718edcfe2242d899d0c97647f0406f.png]

**2.equals() 方法**

在Java中，== 比较符，在比较基本数据类型时，比较的是数据值是否相等。
    而在比较引用数据时，比较的就是两个引用数据的地址值是否相同了。
    (使用new操作符创建的都是引用数据类型)

**注意，在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。**

### 对象类型的转换 ###

**需要注意的是，只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。**

对象之间的类型转换在Java编程中还是很常见的。类型转换分为向上转型与向下转型。
    而向上转型就是将子类对象赋值给父类对象。
    格式为： 父类 对象名 = (父类) 子类对象;
    需要注意得是，在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法。
    只能调用从父类中继承下来的属性与方法。
    所有向上类型转换一般不怎么使用，这里就不多叙述了。

**向下类型转换**

向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。
    但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类，
    而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。

**在进行向下转型时，需要借助强制类型转换。**

子类类型 子类对象 = (子类类型) 父类对象;

class Bird{
        }
    class Pigeon extends Bird{
        
    }
    
    public class Demo_3 {
        
        public static void main(String[] args) {
        
            Bird bird=new Pigeon();	//父类对象引用子类的对象
            Pigeon pigeon= (Pigeon) bird;
        }
    }

**父类对象可以强制类型转换为子类对象，但是有一个前提：这个父类对象要先引用这个子类对象。**

个人理解就是，在将父类对象向下转型前，在创建父类对象时，需要new子类的构造方法，**相当于这个父类对象创建的是子类的实例，只是外面套了一层父类的 “马甲”**，这样才能进行向下转型。  
不然在运行时，编译器会抛出一个异常 **java.lang.ClassCastException**，字面意思理解就是**类转换异常**。

**例如：父类没有实例化子类**

class Bird{
        }
    class Pigeon extends Bird{
        
    }
    
    public class Demo_3 {
        
        public static void main(String[] args) {
        
            Bird bird=new Bird();	//父类没有实例化子类
            Pigeon pigeon= (Pigeon) bird;
        }
    }

![在这里插入图片描述][f6624de75b2e4a078bb2ed66c23fe5e9.png]

### 方法重载 ###

在编写Java程序时，需要应对不同的情况，编写不同的方法，例如：两数相加 的 add 方法。

public static int add(int a,int b){
        
    	return a+b;
    }

这是一个功能非常简单的代码，仅返回两形参相加后的结果。但是如果此时我需要计算两个double类型的变量相加呢？那么需要在编写一个方法，方法好编写，但是方法名呢？取什么名字更好？各位都知道，方法名的定义需要做到见明知义，与功能相符，这样才使得代码的可读性更强。那么同样功能的方法，取什么方法名才好呢？

**重载**  
此时，Java支持一样的一个功能，方法重载，**方法重载支持在同一个类中允许存在多个同名的方法，但是这些同名的方法需要形参表一定不相同，这样才是重载。**

**例如**

public static int add(int a,int b){
        
            return a+b;
        }
        //方法的重载
    public static short add(short a,short b){
        
        return (short) (a+b);
    }
    public static double add(double a,double b){
        
        return a+b;
    }
    public static char add(char a,char b){
        
        return (char) (a+b);
    }

**返回值相同，但是形参列表不相同**

public static int add(double a,int b){
        
            return (int) (a+b);
        }

以上代码都构成重载，注意**构成重载的条件是，方法名相同，但是形参表并不相同。**

`形参表不相同指的是：1、形参个数不同 2、形参类型不同 3、形参顺序不同。`

为什么重载这么在意形参表呢？

因为虚拟机在调用方法时，是根据方法名与传入的参数来调用的。
    重载的方法，方法名是相同的。
    所以虚拟机只能根据传入的形参类型、个数、顺序来调用对应的方法。

**根据传入的形参来调用对应的方法。**  
![在这里插入图片描述][7b449b89b92c4b2996e9adcb48e9e918.png]

### final关键字 ###

final关键字也称静态关键字，在之前的变量章节也已经提到过了。
    被final关键字修饰的变量在代码运行过程中无改变其数据值，也就是变成的常量，无法改变的量。
    关于final关键字用为变量的修饰，这里就不重复叙述了。

**final方法**

被定义为final类型的方法，在被继承后，子类无法重写该方法，无法重写但是可以使用。
    前面提到的权限修饰符private，私有的，被这个修饰符修饰的属性与方法在继承后，子类无法继承该属性或方法。

class Bird{
        
        public final void show(){
        
            System.out.println("父类方法");
        }
    }
    class Pigeon extends Bird{
        
    	//无法重写该方法
        public final void show(){
        
        }
    }

![在这里插入图片描述][1e95b2c0180e4e3b904bb1c05c4b8bce.png]

**final类**

final关键字作用在类上的话，那么该类无法其他类被继承，也不允许其他人对该类进行任何的改动。

格式：final 类名\{\}

final Cat{
        
    }

例如：在Java.lang包的Math类与String类就是被定义为final类，这两个类无法作为父类被继承。

### instanceof关键字 ###

instanceof是Java的关键字，用于判断某个对象是否属于某个类的。
    真则返回true，假则返回false。

**格式：实例化对象 instanceof 某个类**

如果一个方法的形参定义为 在一段继承关系中的父类 (父类是可以接收子类对象)，也就是说这个方法可以接收子类对象，也可以接收父类对象，那么该方法需要针对不同的对象来进行不同的操作的话，这个时候就需要使用到 instanceof 关键字了。

**例如**

class animal{
        
    }
    
    class cat extends animal{
        
    }
    
    class dog extends animal{
        
    }
    
    public class Demo_1 {
        
        public static void main(String[] args) {
        
            cat c=new cat();    //猫类实例化对象
            dog d=new dog();    //狗类实例化对象
    
    /89
    
    325210.
           eat(c);
      9      eat(d);
        }
        public static void eat(animal temp){
        
        	//判断不同类，进行不同的操作
            if(temp instanceof cat){
        
                System.out.println("猫吃猫粮");
            }
            if(temp instanceof dog){
        
                System.out.println("狗吃骨头");
            }
        }
    }

![在这里插入图片描述][abb73364358642c88243a35d0f0b255e.png]

### 多态 ###

**有继承关系的类与类之间才有多态的概念。**

多态就是就是子类的向上转型，子类向上转型前面也已经说过了，这里就不多复述了。  
使用多态能够大量的减少程序冗余的程度，多态通常是定义为某个方法的形参，针对传入参数的实例不同，使用不同的功能，与instanceof关键字配套使用。

**例如：**

class animal{
        
    }
    
    class cat extends animal{
        
    }
    
    class dog extends animal{
        
    }
    
    public class Demo_1 {
        
        public static void main(String[] args) {
        
            cat c=new cat();    //猫类实例化对象
            dog d=new dog();    //狗类实例化对象
    
    /89
    
    325210.
           eat(c);
      9      eat(d);
        }
        //多态，使用父类作为形参，传入不同的实例化的子类进行不同的操作
        public static void eat(animal temp){
        
        	//判断不同类，进行不同的操作
            if(temp instanceof cat){
        
                System.out.println("猫吃猫粮");
            }
            if(temp instanceof dog){
        
                System.out.println("狗吃骨头");
            }
        }
    }

## 抽象类 ##

如果父类中的方法，在子类继承后，子类必须根据自身类的情况来重写该方法时，那么可以将方法定义为抽象方法。或者如果父类只是提供该方法，但是必须让子类重写该方法时，那么可以将该方法定义为抽象方法。

**关于抽象类的两个重要概念：**

1.  一个类中的方法如果被定义为抽象方法，那么该类必须是抽象类，但如果一个类是抽象类，这个类里面不一定有抽象方法。
2.  如果子类继承的父类是抽象类，那么子类必须重写该类中的所有抽象方法。
3.  抽象方法没有方法体。

**抽象类与抽象方法使用 absstract 关键字定义。**

定义抽象类

权限修饰符 abstract class 类名{
        
    }
    
    例如：
    public abstract class eat{
        }

抽象方法的定义也是如此

abstract 方法名(参数表);
    例如：
    	abstract f();

**抽象类实际相当于制定了一个规则，子类必须遵守，再根据子类的自身情况来实现这个规则。**

## 接口 ##

上述我们了解了抽象类的概念，抽象类实际就是提供了一个规则，让子类必须遵守、让子类必须实现。但是类与类之间只能单继承，不能多继承。但是如果子类需要父类提供多个方法呢？那么就是需要用到**接口**了。

**接口可以看做一个纯粹的抽象类，类可以链接多个接口。接口提供方法，类实现接口内功能。**

接口内的方法都是抽象方法，没有方法体。  
类继承了一个方法就要实现接口内中的所有方法。  
**接口使用 interface 关键定义。**

权限修饰符 interface 接口名{
        
    	接口体
    }
    // 定义一个游泳的接口
    public interface swim{
        
    }

**类实现链接接口使用 implements 关键字**

权限修饰符 class 类名 implements 接口名,另一个接口名{
        
    }
    例如：
    public class student implements swim,Listen_to_music{
        
    
    }

**注意一个接口也可以继承另一个接口。**

public interface Listen_to_music{
        
    }
    public interface rest extends Listen_to_music{
        
    }

## 结尾 ##

本章节就暂时学习到这里了，如果本文有错误的地方，还望指出。

[8b92b36a17c84416a9959081532e8090.png]: https://img-blog.csdnimg.cn/8b92b36a17c84416a9959081532e8090.png
[1558318057994258b8a9b494fccbfa9d.png]: https://img-blog.csdnimg.cn/1558318057994258b8a9b494fccbfa9d.png
[e6233dd661724287a88d469833986258.png]: https://img-blog.csdnimg.cn/e6233dd661724287a88d469833986258.png
[fc26152bef8a466184765f31bdede10c.png]: https://img-blog.csdnimg.cn/fc26152bef8a466184765f31bdede10c.png
[47718edcfe2242d899d0c97647f0406f.png]: https://img-blog.csdnimg.cn/47718edcfe2242d899d0c97647f0406f.png
[f6624de75b2e4a078bb2ed66c23fe5e9.png]: https://img-blog.csdnimg.cn/f6624de75b2e4a078bb2ed66c23fe5e9.png
[7b449b89b92c4b2996e9adcb48e9e918.png]: https://img-blog.csdnimg.cn/7b449b89b92c4b2996e9adcb48e9e918.png
[1e95b2c0180e4e3b904bb1c05c4b8bce.png]: https://img-blog.csdnimg.cn/1e95b2c0180e4e3b904bb1c05c4b8bce.png
[abb73364358642c88243a35d0f0b255e.png]: https://img-blog.csdnimg.cn/abb73364358642c88243a35d0f0b255e.png