1.面向对象——继承

继承

• 子类拥有父类非 private 的属性、方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字

1. extends只可以实现单一继承，一个子类只能有一个父类

package com.hmcxy;


class Animal
{
    private String name;
    private int id;
    public Animal(String m_Name,int m_id)
    {
        name = m_Name;
        id =m_id;
    }

    public void eat()
    {
        System.out.println(name+"正在吃");
    }
}
class Dog extends Animal
{
    public Dog(String m_Name,int m_id)
    {
        super(m_Name,m_id);
    }
    public void eat()
    {
//        System.out.println("dog :eat");
        super.eat(); // super 调用父类方法
    }
    void test()
    {
    	this.eat()//this调用自己的方法
    }
}

public class basic {
    public static void main(String[] args) {
        System.out.println("类的继承");
        //错误方法，不可以通过该操作实例化子类对象
//        Dog  dog =new Animal("a",20);
//        dog.eat();
        //方法一：
        Animal dog = new Dog("a",20);
        //方法二：
        Dog dog2=new Dog("b",50);
        
        dog.eat();
        dog2.eat();
    }


}

2. implements可以实现多继承，同时继承多个接口

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

构造器

**子类不继承父类的构造器（构造方法或者构造函数），只是调用。**如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

class A{
  private int n;
  A(){
    System.out.println("A()");
  }
  A(int n) {
    System.out.println("A(int n)");
    this.n = n;
  }
}
// A 类继承
class B extends A{
  private int n;
  
  A(){ // 自动调用父类的无参数构造器
    System.out.println("A");
  }  
  
  public A(int n){ 
    super(200);  // 调用父类中带有参数的构造器
    System.out.println("A(int n):"+n);
    this.n = n;
  }

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写。

final class 类名 {//类体}

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}