java继承

java 继承

继承：就是子类继承父类的特征和行为，使子类对象（实例）具有父类的实例域和方法。或子类从父类继承方法，使得子类具有父类相同的行为。(Java不支持多继承、但支持多重继承)

继承优点：提高代码的复用性、维护性，使代码更加简介。

类的继承格式：
    class 父类{
    
    }
    class 子类 extends 父类 {
    
    }

例：
公共父类

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 + "  .");
      }
   }

老鼠类：

public class Mouse extends Animal
{
	public Mouse(String myName, int myid)
	{
		super(myName, myid);
	}
}

继承的特性

• 子类可以拥有父类非private的属性，方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类。
• 提高了类之间的耦合性（相对缺点是代码的独立性较差）

继承关键字
继承可以使用extends（继承类）和implements（继承接口）这两个关键字实现。并且所有的类都是继承Java.lang.Object。当一个类没有继承关键字，则默认继承object（这个类子在Java.lang包中，所以不需要import）祖先类。

• extends关键字：
  在Java中类的继承是单一继承。

例：

public class Animal
{
	private String name;
	private int id;
	public Animal(String  myName, int myId)
	{
		//初始化属性
	}
	public void eat()
	{
	  ///实现吃东西的具体方法
	}
}
 public class Mouse extends Animal
 {
 }

• implements关键字：
  使用implements 关键字可以变相使Java具有多继承的特性，适用范围是类继承接口的情况，可以同时继承多个接口。
  例：

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

super 与this 关键字

• super关键字：
  我们可以通过super关键字来是新啊对父类成员的访问，用来引用当前的对象的父类。

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

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

public class Test
{
	public static void main(String[] args)
	{
	Animal  a=new Animal();
	a.eat()
	Dog d = new Dog();
	d.eatTest();
	}
}

输出结果：

animal ：eat
dog : eat
animal : eat

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

• 声明类：

      final class 类名 {  //类名}

• 声明方法：
  修饰符（public/private/default/protected final 返回值类型 方法名（）
  {
  //方法体
  }
  注：实例变量也可以被定义为final,被定义为final的变量不能被修改。

构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，他只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式的通过super关键字调用父类的构造器并配以合适的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用super关键字调用父类构造器，系统会自动调用父类的无参数构造器。
例：

class SuperClasss
{
	private int n;
	SuperClass()
	{
		System.out.println("SuperClass()");
	}
	SuperClass(int n)
	{
		System.out.println("SuperClass(int n)");
		this.n = n
	}
}

class subclass extends SuperClass
{
	private int n;
	SubClass()
	{
		super(3000);
		System.out.println("SubClass");
	}
	public SubClass(int n)
	{
		System.out.println(SubClass(int n));
		this.n =n;
	}
}

public class TestSuperSub
{
	public static void main(String args[])
	{
		SubClass sc =new SubClass();
		SubClass sc1 = new SubClass(200);
	}	
}

输出结果：

SuperClass(int n)
SubClass
SuperClass()
SubClass(int n ):200