【JAVA学习笔记】12 包含、继承super

2018.3.29

包含关系

学生和班级，球员和球队，员工和公司？

项目：
	球员管理类。

文件操作：
	歌词解析
	
球员看做一个类。球队看做一个类 

        class Player {
        	//成员变量
        		private	String name;
        		private int num;
        		//无参成员变量
        		public Player() {
        			
        		}
        		//有参成员变量
        		public Player(String name,int num) {
        			this.name = name;
        			this.num = num;
        		}
        		public void setName(String name) {
        			this.name = name;
        		}
        		public String getName() {
        			return name;
        		}
        		public void setNum(int num) {
        			this.num = num;
        		}
        		public int getNum() {
        			return num;
        		}
        		
        	public void shot() {
        			System.out.println("射门不错");
        		}
        	
        }
        
        class Team {
        	private String teamName;//球队名
        	//用球员类对象作为当前Team类成员变量
        	Player p1;
        	Player p2;
        	Player p3;
        	
        	//更加合适的方式是用数组来保存球员
        	
        	Player[] allPlayers = null;
        	
        	public Team() {}
        	
        	//创建球队的时候，要考虑队名和对应的三个球员 BIG3
        	public Team(String teamName, Player p1,Player p2,Player p3){
        		this.teamName=teamName;
        		this.p1=p1;
        		this.p2=p2;
        		this.p3=p3;
        	}
        	public void setTeamName(String teamName) {
        		this.teamName = teamName;
        	}
        	public String getTeamName() {
        		return teamName;
        	}
        	
        	public void game() {
        		System.out.println(this.p1.getName()+","+this.p2.getName()+"和"+this.p3.getName()+"所向披靡");
        	}
        	
        }
        public class Demo1 {
        	public static void main(String[] args) {
        		Player p1 = new Player("lu",3);
        		Player p2 = new Player("梅西",10);
        		Player p3 = new Player("c罗",7);
        		Team big3 = new Team("dt",p1,p2,p3);
        		big3.game();
        		//lu,梅西和c罗所向披靡
        }
        }
结果：
    lu,梅西和c罗所向披靡

继承

父亲和儿子 父子关系

第一顺位继承人

代码中的继承关系
	LOL：
		所有的英雄人物都属于英雄类，在这个类里面规定了英雄应该拥有的属性，血量，攻击力，属性。
		
		但是每一个英雄，例如，凯特琳在这个英雄类的基础上，特定的技能，特定的模型。
		
		在游戏开发中，大量的使用【继承】，来简化代码，提高开发效率
		
		Collections
			list
				Arraylist
				 Linkedlist
				 Verctor
			Set	
				HashSet
				TreeSet
			Map:
				HashMap
				TreeMap

用代码来实现继承关系

在代码中继承使用的关键字是extends，如果一个类通过extends关键字继承了其他类，那么就可以说，当前类是其他类的子类，
	或者其他类是当前类的分类。
	
	【发现】
		1.在创建子类对象的时候，会首先自动调用父类的构造方法
			这里是为了初始化属于父类的成员变量。有其父必有其子。
		2.父类中的【非私有化】成员变量，子类可以通过继承之后获得使用权限。
		3.父类中的【非私有化】成员方法，子类可以通过继承之后得到使用权限。
		4.在父类中用private修饰的私有化成员方法，不能通过继承该类的子类对象来调用
		原因：私有化的成员方法只能在当前类的内部使用，外部没有任何使用权限。
		5.父类中用private修饰的私有化成员变量，这个私有化的成员变量不能通过继承该类的
		子类对象来调用。
		原因：私有化的成员变量只能在当前类的内部使用，外部没有任何使用权限。
		
		【总结】
			在继承中，父类里没有私有话的成员变量和成员方法都可以被子类继承，但是一旦私有话，子类就无法继承这些
			属性或者方法，原理是封装思想。
			
		【注意事项】
			1.继承可以节省代码，提高开发效率，但是在使用继承的时候，前提条件两个类之间的确包含有继承的关系。
			例如，Animal动物类
					dog 
					cat
					绿萝X这个不属于动物类 不能使用继承关系。	


    class Hero {
    	  int blood;
    	  //父类中私有化的成员变量
    	  private int power;
    	public Hero() {
    		System.out.println("父类的hero类的无参构造方法");
    		
    	}
    
    	public Hero(int blood,int power) {
    		this.blood = blood;
    		this.power = power;
    		System.out.println("父类hero类的有参构造方法");
    	}
    	
    
    	//父类hero类里面的成员方法。
    	public void Flash() {
    		System.out.println("闪现");
    		
    	}
    	public void F() {
    		System.out.println("屏障");
    	} 
    	private void Test() {
    		System.out.println("22");
    	}
    }
    //extend 继承的关键字 表示当前vn类是hero类的一个子类 或者hero类是vn类的父类。
    class Vn extends Hero{
    	private String name;//子类的成员变量
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Vn() {
    		System.out.println("子类vn类的的无参构造方法");
    	}
    	public Vn(String name) {
    		System.out.println("子类vn类的有参构造方法");
    	}
    	
    	//子类的自己的方法
    	public void R() {
    		
    		System.out.println("终极时刻");
    	}
    }
    
    
    public class Demo2 {
    	public static void main(String[] args) {
    		//创建一个父类的对象
    		//Hero h = new Hero();
    		
    		//创建继承于hero一个子类的vn类的对象。
    		Vn V = new Vn();
    		
    		//子类对象使用继承与父类得来的【非私有话】成员变量。
    		V.blood = 100;
    		//子类不能使用父类中私有化成员变量。
    		//V.power = 200;
    		//子类使用自己的成员变量
    		V.setName("1");
    		System.out.println(V.getName());
    		V.R();
    		V.F();
    		//子类不能使用父类的私有化成员方法，没有继承权限
    		//V.Test();
    }
    }
    
结果：
    父类的hero类的无参构造方法
    子类vn类的的无参构造方法
    1
    终极时刻
    屏障

Super 关键字

子类在创建对象时候，首先会自动调用父类的构造方法。

【前提】 父类的构造方法，不能被子类继承。

[问题] 在子类中如果通过构造方法初始化从分类继承而来的成员变量，可能会存在一点的隐患，如果直接日用this.成员变量赋值操作， 会导致父类中的成员变量不符合一些业务逻辑或者生活逻辑。 【考虑】 能否借助于父类的构造方法，来初始化原本属于父类的成员变量。 【解决】 借助于super（超，父） 关键字 调用父类方法的关键字

super关键字的注意事项。
		1.super关键字可以在子类中直接调用父类的成员方法。
		2.使用super调用父类的构造方法：
			super(实际参数)；
			java编译器根据不同的参数类型来调用不同的构造方法。
		3.如果用super调用构造方法，必须在当前代码块的第一行。	
		4.this关键字调用构造方和super关键字调用方法不能同时出现在一个代码块中，	
		5.在子类的构造方法中，如果没有通过super指定调用父类的构造方法，那么java编译器会帮我们
		自动调用父类的无参构造方法来使用。（隐式）
			【建议】
				存在继承的关系下，父类中最好提供一个无参的构造方法，供子类使用。
		显示调用 隐式调用

【回顾】 this关键字：调用构造方法的格式： 1.this(实际参数) java编译器会根据不同的参数类型来调用不同的构造方法。 2.如果用this调用构造方法，必须在当前代码块的第一行。 3.两个构造方法不能通过this关键字相互调用 。

class Fu {
    	int age ;
    	String name;
    	public Fu() {
    		System.out.println("无参的父类构造方法");	
    	}
    	public Fu(int age,String name) {
    		if(age<0){
    			this.age = 30;
    		}else{
    			this.age=age;
    		}
    		
    		this.name = name;
    	}
    	public void work() {
    		System.out.println("工作辛苦了");
    	}
    }
    class Zi extends Fu {
    	String hobby;
    	public Zi() {
    		//这里没有用super来调用任何父类中的构造方法。
    		System.out.println("子类无参的构造方法");
    	}
    	public Zi(String hobby) {
    		this.hobby = hobby;
    	}
    public Zi(String name,int age,String hobby){
    	/*
    	 name,age是继承来的，既然是父类的属性，就用分类的方法来初始化。
    	  */
    	super(age,name);//相当于调用父类中两个参数的构造方法，来初始化父类中的成员变量。
    	this.hobby = hobby;
    }
    public void play() {
    	super.work();//super也可不带， 成员方法可直接调用。
    	System.out.println("绝地求生大逃杀。");
    	}
    }
    
    public class Demo3 {
    	public static void main(String[] args) {
    		//这里是匿名对象调用方法
    		new Zi().play();
    		
    	}
    }

结果：
    无参的父类构造方法
    子类无参的构造方法
    工作辛苦了
    绝地求生大逃杀。