面向对象的三个基本特征（继承）（extends和implements）

面向对象的三个基本特征是：封装、继承、多态

继承：

百度上解释的方法为：

继承就是当你写一个类时，虽然这个类满足了某些功能但是你又想拓展它的功能，此时你就可以使用继承机制在写一个该类的子类，来完成你需要的功能，一旦子类继承了父类就拥有了父类的方法与域（除私有方法和私有域），在子类中也可以重写父类的方法，覆盖父类中同名的方法，定义与父类相同的域，隐藏父类同名的域，实现子类需要的功能。

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 

通过继承创建的新类称为“子类”或“派生类”。 

被继承的类称为“基类”、“父类”或“超类”。 

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
如：
兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
那么食草动物类和食肉动物类就是动物的子类
所以继承需要符合的关系是：父类更通用，子类更具体。
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

为什么要继承？

来举个例子吧

开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

企鹅：属性（姓名，id），方法（吃，睡，自我介绍）

老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

//企鹅类：
public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(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 { 
    private String name; 
    private int id; 
    public Mouse(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 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 + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

//企鹅类：
public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}
//老鼠类：
public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

继承的特性

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

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

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

• Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。

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

继承关键字

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

1.extends

extends 有“扩展”的意思：子类是父类的扩展

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

如

class parent {
	public parent(){
		System.out.println("调用父类的构造方法");
	}
}

class subparent extends parent{
	 public subparent(){
		 System.out.println("调用子类subparent（）的构造方法");
	 }
}
public class Son extends subparent{
	 public  Son()
	 {
		 System.out.println("调用子类son的构造方法");
	 }
	 public static void main(String[] args)
	 {
		 Son k = new Son();
	 }
}

2.implements

为了解决之前说的只能单一继承的问题，Java为了能像C++那样多继承，就提供了接口（interface）的概念，接口只有常量和抽象方法。implements有实现的意思，子类在用implements继承了接口的之后，可以直接调用接口中的常量，也可以重写接口中的抽象方法。

接口的定义方法如下：

public interface Canattack{//定义Canattack接口
	void attack();
}

public interface Canmove{//定义Canmove接口
	void move();
}

要记住接口是不能实例化的

public interface IErrorFace
{
    void Error();
}
//错误的使用接口方式：
IErrorFace ef = new IErrorFace();

但我们可以新写一个类来用implements继承这个接口，来通过对这个类的实例化来进行对接口中的方法的实现

注：因为在类中重写了接口中的方法，以后调用接口中的方法实施的就是类中的方法
如

public interface IErrorFace
{
    void Error();
}
    
public class ErrorFace implements IErrorFace
{
   public void Error()
   {
       //TODO
   }
}

//使用接口：
IErrorFace ief = new ErrorFace();
ief.Error();//已在ErrorFace实现接口IErrorFace的方法

我们看一个例子

//接口尝试;

interface A{
	int a=1;
	void way1();
}

interface B{
	void way2();
}

class Print implements A,B{
	public void way1() {//对A接口中的way1（）方法的重写，以后用way1（）就用的是此处的方法
        char[] chr=new char[26];
        char j=65;
        for(int i=0;i<=25;i++){
            chr[i]=j;
            j++;
        }
        System.out.print("大写字母：");
        for(char temp:chr){
            System.out.print(temp);
        }
        System.out.println();
    }

    public void way2() {//同上
        char[] chr=new char[26];
        char j=97;
        for(int i=0;i<=25;i++){
            chr[i]=j;
            j++;
        }
        System.out.print("小写字母：");
        for(char temp:chr){
            System.out.print(temp);
        }
        System.out.println();
    }
}
public class E {
    public static void main(String[] args){
        A a =new Print();//通过类的实例化来进行对接口中的方法的实现
        a.way1();
        System.out.println(a.a);
        B b=new Print();
        b.way2();
    }
}