继承，接口

/**


继承：
成员变量
一个父类可以有多个子类，但是一个子类不能继承多个父类
（防止多个父类中有重名但是功能不同的方法）
java支持多层继承->一个继承体系
如何使用一个继承体系中的功能：
查阅父类的功能（父类具有共性）
创建子类的对象，子类继承了父类的方法，所以创建子类能够使用更多方法，并且有可能父类并不能创建对象
当子类与父类出现了非私有的同名成员变量时，子类要访问本类中的变量，用this
子类要访问父类中的变量，用super。
如果不加关键字默认被子类覆盖
class Fu
{
int num=5;


}
class Zi extends Fu
{
int num=4;
void show(){
System.out.println(super.num);
}
}


class seven
{
public static void main(String[] args){
Zi z=new Zi();
z.show();
System.out.println(z.num);
}
}


成员方法：覆盖 
当子类与父类的方法重名时，运行时会执行子类的方法，父类方法被覆盖
（覆盖的条件：子类权限大于等于父类权限否则编译失败显示不能覆盖）
想要调用，在功能前加super
静态只能覆盖静态
重载：同名但是传递参数不同（参数不同不会覆盖）
重写（覆盖）同名，参数类型一样，返回值类型一样)
比如
int show(){ return 1;}
void show(){ };
||
一个在子类中一个在父类中不能覆盖并且报错
编译器不能分辨出要执行哪个方法


class Fu
{
Fu(){
System.out.println("Fu...");
}
Fu(int x){
System.out.println("Fu..."+"4");
}


}
class Zi extends Fu
{

Zi(){
super(4);
System.out.println("Zi...");
}
Zi(int x){
System.out.println("4");
}
}


class seven
{
public static void main(String[] args){
Zi z=new Zi(4);
Zi zz=new Zi();

}
}










子类一定会访问父类的构造函数，如果程序中让他不能访问父类，会报错
原因：
因为子类可以访问父类的数据，所以子类对象建立时，也要访问父类的构造函数，要对父类的数据进行初始化
注意：子类的构造函数中super语句一定定义在第一行
子类的构造函数第一行都有一个默认的隐式的super();当父类中没有空参数构造函数是，子类必须手动通过super或者this语句形式指定要访问的父类的构造函数（父类中没有空参数构造函数一定有其他的构造函数）
通过this语句可以访问到子类的其他构造函数从而传递到父类的不同的构造函数，子类构造函数中this与super不能共存，因为都需要放在第一行）
想要访问指定的父类的构造函数，可以在子类中手动指定super(参数)
子类中也可以通过this语句访问本类的其他的构造函数
(this语句放在第一行)


class Fu
{
Fu(){
System.out.println("Fu...");
}
Fu(int x){
System.out.println("Fu..."+x);
}


}
class Zi extends Fu
{

Zi(){
System.out.println("Zi...");
}
Zi(int x){
this();
System.out.println("Zi"+x);
}
}


class seven
{
public static void main(String[] args){
Zi z=new Zi(4);

}
}
运行结果： Fu... Zi... Zi4


class Person
{
String name;
Person(String name){
this();
}
Person(){
name="vae";}
void show(){
System.out.println("name= "+name);
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}

}
class seven
{
public static void main(String[] args){
Student z=new Student("zxr");
z.show();
}
}
//父类中已经有name的初始化，在子类中无需再次初始化，只需要引用父类的构造函数即可
//所以直接写super(name);如果不写默认是super();空参数，而父类中已经没有默认的空参数的构造函数了，会报错
//另外在父类中不能用this();










模板方法设计模式
练习：


abstract class GetTime
{
public final void getTime(){//计时器，不能被复写


long start=System.currentTimeMillis();


runcode();


long end=System.currentTimeMillis();


System.out.println("毫秒： "+(end-start));
}
abstract void runcode();//抽象函数
}
class Run extends GetTime
{
//复写父类的抽象函数，抽象函数实例化
void runcode(){
for(int i=0;i<5000;i++)
System.out.print(i);
}
}


class seven
{
public static void main(String[] args)
{
Run s=new Run();


s.getTime();
}


}


练习2
 abstract class GetTime
{
public final void getTime(){


long start=System.currentTimeMillis();


run();


long end=System.currentTimeMillis();


System.out.println("time="+(end-start));
}
abstract void run();
}
class Run extends GetTime
{
void run(){
for(int i=0;i<500;i++)
System.out.print(i);
System.out.println();
}
}
class seven
{
public static void main(String[] args){
new Run().getTime();
}
}














接口:初期：可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示；
class用于定义类
interface用于定义接口


1.接口中常见定义：常量，抽象方法；
2.接口中的成员 都有固定修饰符
常量：public static final
方法：public abstract
总结：接口中的成员都是public的
接口不能创建对象，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才能实例化
（全部都是public）否则子类也是一个抽象类


interface Inter
{
public static final int NUM=3;
public abstract void show();
}


class Test implements Inter
{
public void show(){}
}


class seven
{
public static void main(String[] args)
{
Test t=new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}
}
输出结果：3 3 3
因为NUM是静态的，所以可以直接被访问






Test,Demo为类，InterA，B，C为接口
接口和类之存在间实现关系（InterA也可能继承了InterC）


class Test implements InterA,InterB
{
}


接口可以被类多实现（继承时，不能多继承就是一个子类不能有多个父类，防止父类们的名字一样时，子类无法分辨执行那一个功能，
但是接口多实现来说，不会出现这一问题，因为父类们的方法都是抽象的，没有方法体，任由子类来定义）
一个类可以先继承父类，再实现接口的功能，增加自己的功能


class Test extends Demo implements InterA,InterB
{
}


接口和接口之间可以继承，并且存在多继承


interface InterC extends InterB,InterA
{
}


一个类可以实现接口（一堆进行了继承的接口最终一个类可以实现他们的所有抽象方法）
*/
接口举例实现
abstract class Student
{
abstract public void study();
public void sleep(){
System.out.println("sleeping...");

}
}
interface Smoking
{
public abstract void smoke();
}
class zhangsan extends Student implements Smoking
{
public void study(){}
public void smoke(){} 
}
classs Lisi extends Student
{


}