package snippet;



public class Snippet {





public Snippet(){

System.out.println("Snippet 无参构造函数");

}



public void hanshu(){

System.out.println("Snippet hanshu（）");

}



public void sniCongXie(){

System.out.println("Snippet sniCongXie（）");

}

 

 

static public void statichan(){

System.out.println("Snippet statichan（）");

}



final public void SnippetFinal(){

System.out.println("Snippet SnippetFinal（）");

}

}

package snippet;

import org.junit.Test;

public class Son extends Snippet {


public Son(){
System.out.println("Son 无参构造函数");
}

public void hanshu(){
System.out.println("Son hanshu（）");
}

public void sniCongXie(String name){
System.out.println("Snippet sniCongXie（）  的办法被重写");
}

public void Sonbanfa(){
System.out.println("Son Sonbanfa（）");
}

static public void statichan(){
System.out.println("Son statichan（）");
}

public static void main(String arg[]){

Snippet sni=new Son();//Snippet 无参构造函数        Son 无参构造函数，先执行父类的构造函数，再执行子类的构造函数
// sni.Sonbanfa();无法调用，因为该办法是子类办法，对于父类不可见

Son sons= new Son();//Snippet 无参构造函数        Son 无参构造函数，先执行父类的构造函数，再执行子类的构造函数
sons.sniCongXie("重写");//Snippet sniCongXie（）  的办法被重写

//sni.sniCongXie("重写"); 父类不可见，因为该办法已经被子类重写，对于父类来说就是子类自己私有的办法
sons.sniCongXie();//Snippet sniCongXie（）  可见，因为继承，所以子类对象能调用

    sons.Sonbanfa();//Son Sonbanfa（）  ->子类自己的办法自己才能调用
sons.statichan();//Son statichan（）->执行的是子类的办法，静态办法，谁的对象谁调用就是谁的办法

sni.hanshu();//Son hanshu（）->执行的是子类的办法，父类的被覆盖了
sni.statichan();//Snippet hanshu（）->执行的是父类的办法，静态办法，谁的对象谁调用就是谁的

sni.SnippetFinal();//Snippet SnippetFinal（）
sons.SnippetFinal();//Snippet SnippetFinal（）,被final修饰的办法，能被子类调用，但是不能被覆盖和重写

}

}