java04

目录

继承

继承关键字：

extends关键字：

implement关键字

this super关键字

final 关键字

构造器

重写和重载

java 的重写

方法的重写规则

super关键字的使用

重载

重载规则：

重写和重载的区别:

---

---

继承

继承的特性：
子类拥有父类非private的属性方法
子类可以拥有自己的水性和方法，即子类可以对父类进行扩展
子类可以使用自己的方法实现父类的方法
java的继承是单继承，但是也可以是多重继承，单继承就是一个子类只能继承一个父类。多重继承就是爷爷 爸爸 孙子这种
提高了类之间的耦合性（继承的缺点，耦合度越高就会造成代码之间的联系越紧密，代码的独立性越差。

继承关键字：

继承可以使用extends 和 implements两个关键字来实现继承，并且所有的类都继承于java.lang.object,当一个类没有继承的两个关键字时，则默认继承object祖先类

extends关键字：

在java中，类的继承是单一继承，也就是说，一个子类智能拥有一个父类，。因此extend只能继承一个类

class animal01{

    private String name;
    private int id;
    public animal01(String name,int id){
        this.name=name;
        this.id=id;
    }
    public void eat(){}

    public void sleep(){}
}
 class qie02 extends animal01{
     public qie02(String name, int id) {
         super(name, id);
     }
 }

implement关键字

使用implement关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口和接口之间采用逗号分隔）

 interface A {
     void eat();
     void sleep();
 }

 interface B {
    void show();
}

abstract class C implements A,B {
}

this super关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
this关键字：指向自己的引用，引用当前对象，即它所在的方法或构造函数所属的对象实例

class Animal {
    void eat02() {
        System.out.println("animal : eat");
    }
}

class Dog extends Animal {
    void eat02() {
        System.out.println("dog : eat");
    }
    void eatTest() {
        this.eat02();   // this 调用自己的方法
        super.eat02();  // super 调用父类方法
    }
}

final 关键字

final的含义可以；理解为最终的，使用fina关键字就是把类定义为最终类，不能被继承。或者用于修饰方法，该方法不能被子类重写
声明类：final class 类名{类体}   声明方法：修饰符（访问修饰符）返回值类型 方法名（）{方法体}

构造器

子类是不继承父类的构造器（构造函数或者构造方法）的，它只是调用（隐式或者显式），
 如果父类的构造器带有参数，则必须在子类的构造器中显示的通过Super关键字调用父类构造器。
 如果父类的构造函数没有参数，则不需要使用super进行调用，系统会自动调用父类的无参构造函数

class superclass{
    private int i;
    public superclass(){
        System.out.println("调用了无参的构造函数");
    }
    public superclass(int x){
        this.i=x;
        System.out.println("调用了有参的构造函数");
    }
}

class superclass01 extends superclass{

    public superclass01(int i){

        super(i);
        System.out.println("子类构造函数"+i);
    }
    public superclass01(){
        System.out.println("子类构造函数");
    }

}
public class Main04 {
     public static void main(String[]args)
     {

superclass sp=new superclass();
superclass01 sp01=new superclass01();
         superclass01 sp02=new superclass01(1);
}
}

重写和重载

java 的重写

重写：重写是指子类定义了一个与其父类中具有相同名称、参数列表、返回值类型的方法，并且子类方法覆盖了父类方法的实现，即外壳不变核心重写 重写的好处在于子类可以根据需要，定义自己的行为，也即是说子类可以选择性的实现子类的方法 重写方法不能抛出新的异常或者比被重写方法申明更加宽泛的异常 在面向对象的原则里，重写意味着可以重写现有的所有方法

class Animal02{
    public void move(){
        System.out.println("动物可以移动");
    }
}

class Dog01 extends Animal02{
    public void move(){
        System.out.println("狗可以跑和走");
    }
}
 class TestDog02{
    public static void main(String args[]){
        Animal02 a = new Animal02(); // Animal 对象
        Animal02 b = new Dog01(); // Dog 对象

        a.move();// 执行 Animal 类的方法

        b.move();//执行 Dog 类的方法
    }
}



class Animal03{
    public void move(){
        System.out.println("动物可以移动");
    }
}

class Dog03 extends Animal03{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark01(){
        System.out.println("狗可以吠叫");
    }
}
 class TestDog03{
    public static void main(String args[]){
        Animal03 a = new Animal03(); // Animal 对象
        Animal03 b = new Dog03(); // Dog 对象
        Dog03 c=new Dog03();
        a.move();// 执行 Animal 类的方法
        b.move();//执行 Dog 类的方法
        ((Dog03) b).bark01();//不能直接访问animal的方法
        c.bark01();
    }
}

方法的重写规则

参数列表必须与被重写方法的参数列表完全相同
返回类型和被重写方法的返回值类型可以不相同，但是必须是父类返回值的派生类
访问权限不能比父类中被冲写的房方法更低
父类的成员方法只能被他的子类重写
声明为final的方法不能被重写
声明为static的方法不能被重写，但是可以被在此声明
子类和父类在同一个包中，那么子类可以重写父类的多有方法除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写
如果不能继承一个类，则不能重写该类的方法

super关键字的使用

class Animal04{
    public void move(){
        System.out.println("动物可以移动");
    }
}

class Dog04 extends Animal04{
    public void move(){
        super.move(); // 应用super类的方法
        System.out.println("狗可以跑和走");
    }
}

 class TestDog04{
    public static void main(String args[]){

        Animal04 b = new Dog04(); // Dog 对象
        b.move(); //执行 Dog类的方法

    }
}

重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。

重载规则：

被重载的方法必须改变参数列表(参数个数或类型不一样)；方法名相同，参数列表不同
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

class OverLoading{
    public int test(){
        System.out.println("test1");
        return 1;
    }
    public  void test(int b){//方法重载
        System.out.println("test2");
    }
}

重写和重载的区别:

区别点 重载方法   重写方法
参数列表   必须修改   一定不能修改
返回类型   可以修改   一定不能修改
异常     可以修改   可以减少或删除，一定不能抛出新的或者更广的异常
访问     可以修改   一定不能做更严格的限制（可以降低限制）