Java第七章总结

序章

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


类的继承

继承关系的定义

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


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

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

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


错误代码

class C extends A,B{
}

Java第七章总结_第1张图片

 

允许多重继承

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

Java第七章总结_第2张图片

继承关系的好处

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

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

​

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

​


Java第七章总结_第3张图片
子类继承父类后,在创建子类对象的同时,会先调用父类的构造方法。

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

Java第七章总结_第4张图片 


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

Java第七章总结_第5张图片
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、形参顺序不同。
为什么重载这么在意形参表呢?

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

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

Java第七章总结_第6张图片
final关键字

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

final方法

被定义为final类型的方法,在被继承后,子类无法重写该方法,无法重写但是可以使用。
前面提到的权限修饰符private,私有的,被这个修饰符修饰的属性与方法在继承后,子类无法继承该属性或方法。
class Bird{
    public final void show(){
        System.out.println("父类方法");
    }
}
class Pigeon extends Bird{
	//无法重写该方法
    public final void show(){
    }
}

Java第七章总结_第7张图片

 

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

Java第七章总结_第8张图片
结尾
本章节就暂时学习到这里了,如果本文有错误的地方,还望指出。

你可能感兴趣的:(java,jvm,servlet)