java学习基础（继承）

java学习 _04_day

java学习04_day，主要自己理解继承有关的注意事项和关键字的使用，
如有出错的地方您可以指点出来，让小白多学习习，不要被错误点给误导

private 关键字

    在父类中，被private 修饰后的方法只能被自己使用，而子类就不能使用（不想被继承），
    子类可以定义相同名以及相同属性的方法，互不干扰。
    但可以在父类中可被调用的方法中调用被private修饰的方法，以便子类使用；

    在父类中被private 修饰后的属性，子类只能通过set、get方法进行调用使用；

final 关键字

  1.在父类中被final修饰后的方法子类不能对其方法进行重写；

程序加载顺序

    在程序加载中：先是执行父类中的构造函数然后在执行子类中的构造函数
    （如果类中有静态代码块...静态相关的  修饰代码先加载静态有关的代码，然后再加载构造函数）
    例子看下面代码运行结果。

重写and 重载

   重写：是存在于子类与父类之间存在的关系，在子类中重写父类
   相同的方法名，相同的返回值，相同的参数列表，然后重写不一样的方法内容。
  重载：是存在于本类中一种行为。
  对本类中的方法就行重载就是，方法名相同，返回值不同，参数列表不同的方法。

代码例子如下：

Animal 父类

public class Animal {	
//属性
	private String an_anme;
	private String an_color;
	
	public String getAn_anme() {
		return an_anme;
	}
	public void setAn_anme(String an_anme) {
		this.an_anme = an_anme;
	}
	public String getAn_color() {
		return an_color;
	}
	public void setAn_color(String an_color) {
		this.an_color = an_color;
	}
	

	public Animal() {
		super();
		System.out.println("Animal无参构造函数被调用");
	}

	public Animal(String an_anme, String an_color) {
		super();
		this.an_anme = an_anme;
		this.an_color = an_color;
	}
	
//方法

  /*被private 修饰后的方法不能被子类调用，只能自己使用*/		
	
	private void anAnimalEat(){
		System.out.println("吃的行为....");
	}
	
	public void anAnimalSleep(){
		System.out.println("睡觉的行为.....\n下面是调用被private修饰的方法");
		this.anAnimalEat();                  //对上面private修饰的方法自己进行调用
	}
   
    // anAnimalEat()方法的重载
    public void anAnimalEat(String name){	
		System.out.println("吃的方法重载后："+name+"在吃....");
	}
	
	/*方法被final修饰后，子类不能再进行重写*/
	final public void anAnimalCall(){    
		System.out.println("嗷嗷的叫.....");
	}
	
	/*被final 修饰后的方法可进行方法的重载*/
	
	public void anAnimalCall(String name){
		System.out.println(name+"在嗷嗷的叫.....");
	
static{
		System.out.println("Animal类中的静态代码块被调用");
	}
}

Herbivorous 类 继承 Animal 父类

public class Herbivorous extends Animal {
//属性
	private String angle; //角

	public String getAngle() {
		return angle;
	}
	public void setAngle(String angle) {
		this.angle = angle;
	}

	public Herbivorous() {
		super();
		System.out.println("Herbivorous无参构造函数被调用");
	}
	
	public Herbivorous(String angle) {
		super();
		this.angle = angle;
	}
	
//方法
	
	public void anHerbivorousCall(){
		System.out.println("在叫.....");
	}
	public void anHerbivorousCall(String name){
		System.out.println("方法重载后====>"+name+"在叫.....");
	}
	
	//不能重写Animal父类中被final修饰nAnimalCall()的方法，下面的写法所以是错误的
		
	/*public void anAnimalCall(){
		System.out.println("咩咩的叫.....");
	}*/
	
		
	public void anAnimalSleep(){
		System.out.println("睡觉方法被重写！");
	}
	
	static{
		System.out.println("Herbivorous 类中的静态代码块被调用");
	}
}

Sheep 类 继承 Herbivorous 父类

public class Sheep extends Herbivorous {
	
	public Sheep(){
		super();
		System.out.println("Sheep无参构造函数被调用");
	}
	
//方法
	public void anSheepCall(){	
		System.out.println(super.getAn_anme()+"的"+super.getAn_color()+"小羊咩咩叫...咩咩咩...       还长有两个"+super.getAngle());    
	}

static{
		System.out.println("Sheep 类中的静态代码块被调用");
	}
}

定义一个 AnimalMain 类

public class AnimalMain {	
	public static void main(String[] args) {
		
		Sheep xxSheep=new Sheep();
		// TODO Auto-generated method stub
		xxSheep.setAn_anme("喜洋洋");    //调用父类方法，给属性赋值
		xxSheep.setAn_color("白色");
		xxSheep.setAngle("短角");
		
		xxSheep.anSheepCall();	
		xxSheep.anAnimalEat("夕阳羊");  //调用父类Animal中重载后的方法
		xxSheep.anAnimalSleep();       //调用父类中方法中调用private修饰的方法
		
		xxSheep.anAnimalCall();        //调用final修饰的方法
		xxSheep.anAnimalCall("灰太狼");    //调用final修饰方法重载后方法
		 
	    //xxSheep.anAnimalEat();       //不能调用父类Animal中被private修饰后的私有方法
		xxSheep.anAnimalEat("懒洋洋");  //调用父类Animal中被private修饰后的重载方法
		
		xxSheep.anHerbivorousCall();        //调用父类Herbivorous中的方法
		xxSheep.anHerbivorousCall("美羊羊");  //调用重载的方法
	    
	}

}

运行结果如下：

Animal类中的静态代码块被调用
Herbivorous类中的静态代码块被调用
Sheep类中的静态代码块被调用

Animal无参构造函数被调用
Herbivorous无参构造函数被调用
Sheep无参构造函数被调用

喜洋洋的白色小羊咩咩叫…咩咩咩…还长有两个短角

吃的方法重载后：夕阳羊在吃…

睡觉的行为…
下面是调用被private修饰的方法
吃的行为…

嗷嗷的叫…
灰太狼在嗷嗷的叫…

吃的方法重载后：懒洋洋在吃…

在叫…
方法重载后====>美羊羊在叫…