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类型的实例。

1
调用方式

类名.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();    //狗类实例化对象

        eat(c);
        eat(d);
    }
    public static void eat(animal temp){
    	//判断不同类，进行不同的操作
        if(temp instanceof cat){
            System.out.println("猫吃猫粮");
        }
        if(temp instanceof dog){
            System.out.println("狗吃骨头");
        }
    }
}

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