Java第七章总结

类的继承

继承关系的定义:

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

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

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

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类是Java中的顶级父类，在Java中所有类都直接或间接的继承与Object类，它是所有类的父类。 

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操作符创建的都是引用数据类型)

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

class Bird{}
class Pigeon extends Bird{
}

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

方法重载
在编写Java程序时，需要应对不同的情况，编写不同的方法，

这是一个功能非常简单的代码，仅返回两形参相加后的结果。但是如果此时我需要计算两个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);
}

final关键字

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

instanceof关键字 

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

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

 

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

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

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

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

权限修饰符 abstract class 类名{
}

例如：
public abstract class eat{} 

 

接口 所有方法都是抽象类

修饰符 interface 接口名{}

实现 implement{

Java语言每个类可以实现多个接口

修饰符 class 类名 implements 接口1,接口2 ,...{}

}

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