1.继承写法

公共继承(父类)

package basicForMando;
public class Animal {
    private String name;
      private int id;
      //构造函数    如果未定义
      public Animal(String myName,int myid){
          name = myName;
          id = myid;
      }
      public void eat(){
       System.out.println(name+"正在吃");
      }
      public void sleep(){
          System.out.println(name+"正在睡");
      }
      public void introduction(){
          System.out.println("大家好!我是"+id+"号"+name+".");
      }

}

继承公共函数(子类)

package basicForMando;
//1.extends 父类
public class Penguin extends Animal {
//2.子类构造函数与父类构造函数参数应该相同,如果父类为隐式构造函数,子类可不定义
      public Penguin(String myName, int myid) {
          super(myName, myid);      
   }    
}

2.super&this

1.我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

2.super用法

  * 方法super.a();
  * 在子类构造函数写构造函数super();
  * 变量super.b

package basicForMando;
/*
 * 父类 
 * 成员变量 count
 * 构造函数 有参 无参
 *  普通函数    value()
 *  */
class Fu{
    String str="父类默认";
    int number  = 3;
    //父类构造函数
    Fu() {
        // TODO Auto-generated constructor stub
        System.out.println("fu constructor run ..无参父类.."   );
    }
    public void value() {
        // TODO Auto-generated method stub
        str ="父类value方法内";
    }
    Fu(int x){
        
        System.out.println("fu 构造函数 ..int.." + x  );
    }
    
}
class Zi extends Fu{
    //子类构造函数    写super 
    Zi(){
        
        System.out.println("zi  构造函数    ..无参.."+super.number  );
    };
    Zi(int x){
        super(x+1);
        System.out.println("zi 构造函数 ..int.." + x);
    };
     public void value() {
         str ="子类方法内";  
         System.out.println("str子="+str);
         super.value();      //调用父类的方法
          System.out.println("str="+str);   //这块str 为什么是父类的呀 
          System.out.println("父类str="+super.str);
          
     }
    
}
//继承
public class ExtendsDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Zi z= new Zi();
        //      Zi  z= new Zi(1);
        z.value();
        
    }

}

print(输出)

fu constructor run ..无参父类..
zi 构造函数 ..无参..3
str子=子类方法内
str=父类value方法内
父类str=父类value方法内

3.this关键字：指向自己的引用。

3.implements (多继承的特性)

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

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

4.final 修饰

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

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

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

5.重载和重写

class Animal{ 
  public void move(){ 
  System.out.println("动物可以移动"); 
  } 
} 
class Dog extends Animal{ 
  public void move(){ 
    System.out.println("狗可以跑和走");
  } 
} 
public class TestDog{ 
  public static void main(String args[]){ 
    Animal a = new Animal(); // Animal 对象 
    Animal b = new Dog(); // Dog 对象 
    a.move();// 执行 Animal 类的方法 
    b.move();//执行 Dog 类的方法 
  } 
}