继承和接口

接口

接口是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口的特性
接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

接口中的方法不能有方法体，只能由实现接口的类来实现接口中的方法。

接口的实现类要实现接口中的所有方法，除非实现接口的类是抽象类。

接口无法被实例化，但是可以被声明 ，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类的区别
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口和抽象类的区别
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

接口是用来建立类与类之间的协议，它所提供的只是一种形式，而没有具体的实现。同时实现该接口的实现类必须要实现该接口的所有方法，通过使用implements关键字。 接口是抽象类的延伸，java为了保证数据安全是不能多重继承的，也就是说继承只能存在一个父类，但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多重继承的缺陷， 
语法方面： 
1.由interface关键词修饰的称之为接口； 
2.接口中可以定义成员变量，但是这些成员变量默认都是public static final的常量。 
3.接口中没有已经实现的方法，全部是抽象方法。 
4.一个类实现某一接口，必须实现接口中定义的所有方法。 
5.一个类可以实现多个接口。

1、接口都是用interface修饰的，但他仍是以Java为后缀的源文件，最终运行时也会像类那样编译成class文件

2、在接口中不可以定义变量，定义的属性都是常量，默认public static final 修饰变量，也可以直接写数据类型等于某个值，也是可以的，尽管不写，系统会默认加上public static final

public interface In{
public static final int a=10;
int b=10;

}

3、接口定义成员方法时，方法是用abstract进行定义的 ，在jdk8之后，也可以定义静态方法，但不常用

public abstract void st();

4、接口中不能创建对象，也不可以构造方法

In in=new In();

public interface In{
public static final int a=10;
int b=10;
public abstract void st();

public In(){

}
}

接口于类之间不是继承，而是实现implements，同时Java是支持类多实现接口的，需要用，分开，在实现接口的时候 ，需要注意，如果接口内有其他方法，那么必须将在实现类中把方法重写才行
5、如果一个类需要继承其他类，同时也需要去实现其他接口，那么必须时先继承类，然后再实现接口

public class Test1 extends Test implements In,In1{

   @Override
   public void st(){

}
}

6、接口与接口之间属于多继承，一个接口同时可以继承多个接口
这里要分清，类属于单继承，接口属于多继承
 

继承

继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关Java继承的知识。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

当一个子类中一个实例方法具有与其父类中的一个实例方法相同的签名（指名称、参数个数和类型）和返回值时，称子类中的方法“重写”了父类的方法。例如：

class A{
    public void Hello() {                      //输出英文欢迎
        System.out.println("Hello,Java!!!");
    }
    public void Bye() {
        System.out.println("GoodBye");
    }
}

class B extends A {           
    public void Hello() {                      //输出中文欢迎  
        System.out.println("大家好，欢迎学习Java!!!");
    }
}

public class myfirst {
    public static void main(String[] args) {
    B b=new B();                                //创建子类B的一个实例对象，使用默认构造方法
    b.Hello();                               //调用子类中重写的方法
    b.Bye();                                 //调用父类中的方法
    }
}

运行结果为：

大家好，欢迎学习Java！！！
GoodBye

继承的特性
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）

从继承的概念来说，private不被继承

但从内存的角度来说，父类的一切都被继承（从父类构造方法被调用就知道了，因为new一个对象，就会调用构造方法，子类被new的时候就会调用父类的构造方法，所以从内存的角度来说，子类拥有一个完整的父类）。

但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。

子类可以继承父类的所有成员跟方法，继承下来不代表可以访问，要访问得看访问控制规则。私有属性也可以继承，不过根据访问控制规则，私有属性虽继承下来却不可以访问的，
只有通过public的方法才能访问继承下来的私有属性。

子类可以继承父类所有的属性和方法（包括Private私有属性和方法），不过子类不可以直接访问到父类的Private属性和方法

子类访问父类私有成员
子类继承其父类的所有public和protected成员，但不能继承其父类的private成员。那么如何在子类中访问到父类中的字段呢，我们可以在父类中提供用来访问其私有字段的public或protected方法，子类使用这些方法来访问相应的字段。例如：

class A{                     //父类A
    private int value=10;    //声明一个私有变量value并赋值为10
    public int getvalue() {  //声明一个公有成员方法getvalue，返回value
        return value;
    }
}
class B extends A{           //A的子类B
}
public class myfirst {    
    public static void main(String[] args) {
      B b=new B();           //创建子类B的一个实例对象
      System.out.println("子类通过父类提供的公共接口访问A中的私有字段value:"+b.getvalue());
    }
}
运行结果为：

子类通过父类提供的公共接口访问A中的私有字段value:10

使用super关键字
使用super调用父类中重写的方法、访问父类中被隐藏的字段
子类重写了父类中的某一个方法，隐藏父类中的字段，假如想在子类中访问到父类中被重写的方法和隐藏父类的字段，可以在子类中通过使用关键字super来调用父类中被重写的方法和访问父类中被隐藏的字段。例如：

class A{
    public String name="张三";         //添加成员变量
    public void a() {                //添加成员方法a
        System.out.println("我是父类A成员方法a");
    }
}

class B extends A{
    public String name="李四";         //与父类中同名的字段，隐藏父类
    public void a(){                 //重写方法a
        super.a();                   //使用super关键字调用父类中的方法
        System.out.println("我是子类B成员方法a");
        System.out.println("父类的name名字："+super.name); //使用super关键字访问父类中的变量
    }
}

public class myfirst {
    public static void main(String[] args) {
      B b=new B();                     //创建子类的一个实例对象
      b.a();                         //调用子类中重写的方法
      System.out.println("子类的name名字："+b.name);   //调用子类中的name
    }
}

运行结果为：

我是父类A成员方法a
我是子类B成员方法a
父类的name名字：张三
子类的name名字：李四