Java语言学习06

1. 继承

//继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

//关键字：extends ，子类是父类的扩展，子类可以用父类中的所有方法和属性。（但是子类无法继承父类的私有属性）

//Java中只有单继承没有多继承。（可以间接继承多个，比如爷爷）

比如写了一个Student类，一个Teacher类，一个Person类，那么要定义Student和Teacher类继承Person类，可以这样：

public void Student extends Person（）{}

//Java中，所有的类都默认直接或者间接继承object类，也就是说，就算你创建的这个类里没有任何方法，你也可以用object的全部方法。

2.super

super和this相对应，this指当前这个类，super指父类。（一般用于子类和父类方法重名，然后还都要调用的情况）

如 this.print 和super.print

//隐藏代码：调用了父类的无参构造 super();

调用了父类的构造器，必须要在子类的第一行。

//super和this不能同时调用构造方法

3.方法重写（同样是alt+insert进入）

//方法重写的前提：需要有继承关系，必须是子类重写父类的方法，两者方法名必须相同（不能是父类重写子类，也不能是重写属性，必须是方法）

//重写都是方法的重写，和属性无关。重写只跟非静态方法有关 （没有static）

//@后面加一些东西：有功能的注释（//，/* */）

@override就代表了方法的重写

重写的关键词只能是public，不能是private

//静态方法

子类方法：

public class Demo02 extends Demo03{

public static void print(){
    System.out.println("AAA");
}

}

父类方法：

public class Demo03 {

public static void print(){
    System.out.println("BBB");
}

}

主程序：

public class Demo01 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        demo02.print();
        Demo03 demo03 = new Demo02();
        demo03.print();
    }
}

结果为：

//非静态方法

子类：

public class Demo02 extends Demo03{

    @Override
    public void print() {
        System.out.println("WSSB");

/*

原来是 super.print();我们将其改为输出“WSSB”即完成了方法重写

*/
    }
}

父类：

public class Demo03 {
    public  void print(){
        System.out.println("BBB");
    }
}

主程序：

public class Demo01 {
    public static void main(String[] args) {
        Demo02 a = new Demo02();
        a.print();
        Demo03 b = new Demo02();
        b.print();
    }
}

结果为：

总结：

//静态方法调用只和左边，定义的数据类型有关

//非静态：重写

重写方法之后，都是调用的子类的方法。

方法重写：

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大但是不能缩小

Public->Protected->Default->private

•  抛出的异常：范围可以被缩小，但不能扩大：

ClassNotFoundException-->Exception

方法重写的原因：

父类的功能，子类不一定需要，或者不一定满足。

1. 多态

//存在条件：继承关系，方法需要重写，父类引用指向子类对象！

father f1 = new Son();

//多态是方法的多态，属性没有多态

//父类和子类有联系，类型转换异常（我也不太懂 ）

以下不能重写，所以更没有多态

Static，final，private

//instanceof关键字：判断一个对象是什么类型

Student a = new Student();
System.out.println(a instanceof Object);

结果输出：true，证明a和object有继承关系。

实际过程中：

System.out.println(A instanceof B);

看能不能编译通过

//类型转换-->(方便方法的调用，减少重复代码)

低转高，自动转换（）

高转低，强制转换

son father

father a = new son();

如子类中有方法，walk();父类定义的对象要想使用这个方法，就得：

((son) a).walk();

1. static详解

定义一个静态变量

public class helll

public static int a = 1;

helll qw = new helll();

那么我们可以通过这三种直接调用

System.out.println(a);
System.out.println(helll.a);
System.out.println(qw.a);

//非静态方法可以调用静态方法，反之不可以。

//static静态代码块只在主程序中执行一次

Static{……}

//匿名代码块用来赋初值

{……}

//静态导入包：

import java.lang.Math.random;会报错

只需在java前加一个static

1. 抽象类（真抽象）

还是有继承的关系（extend）

Java里面的类没有多继承，但是接口可以多继承。

如抽象类：

public abstract class Student{}

7.接口

//接口就是规范，自己无法写方法，定义的是一组规则，是契约，所有的都有遵守它。

//声明类的关键字是class，声明接口的关键字是interface。

//接口中的所有定义都是抽象的。里面的方法默认都是public abstract的。所以可以直接 void run（）;

//接口需要有实现类，接口里写抽象的方法，实现类写具体的方法。

写一些简单的接口：（只有方法的定义，而没有具体的实现）

public interface Student{}

写一些简单的实现类：

public class acc implements Student{}

//这个实现类不仅可以实现一个接口方法，还可以实现多个接口方法，利用接口实现多继承。

//实现类需要重写接口中的方法，接口--抽象的能力。

1. 内部类

就是在一个类中定义了另一个类。

代码展示;

通过外部实例来实例化内部类。

8.

//在java API 中已经定义了许多异常类，这些异常类分为错误Error和异常Exception。

//我们将异常当成对象来处理，并定义一个基类java.lang.Throwable,作为所有异常的超类。

//Throwable分为Error和Exception，前者由JVM生成抛出，属于灾难性的致命错误，会终止整个线程。后者可以被程序处理，也可能只需要抛出一些异常就可以解决。

//异常处理机制包括：抛出异常，捕获异常，主要关键字：try,catch,finally,throw,throws.

Try{         //监视异常区域

}catch(){ //括号中为希望捕获的异常

}finally{ //finally选用，不管怎样都会执行

}

//快捷键：ctrl + alt + T 自动生成异常抛出代码

1. 自定义异常

java里面给我们提供的异常有很多，但是也可以自定义异常

public class zdy extends exception { }

自定义异常类：

测试类：

经验总结：