Java第七章总结

序章

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

类的继承

继承关系的定义

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

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

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

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

错误代码

class C extends A,B{
}

允许多重继承

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

继承关系的好处

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

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

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();
    }
}

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

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();
    }
}

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());
    }
}

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;
    }
}

方法重载

在编写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、形参顺序不同。

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

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

根据传入的形参来调用对应的方法。

final关键字

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

final方法

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

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

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("狗吃骨头");
        }
    }
}

多态

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

多态就是就是子类的向上转型，子类向上转型前面也已经说过了，这里就不多复述了。
使用多态能够大量的减少程序冗余的程度，多态通常是定义为某个方法的形参，针对传入参数的实例不同，使用不同的功能，与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{
}

结尾

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