黑马程序员——继承、final关键字、抽象类



------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

<继承>

兴趣是学习编程最好的老师

不积跬步，无以至千里

这辈子没办法做太多事情，所以每一件都要做到精彩绝伦。

1.继承：

 1).继承可以增加代码复用，我们可以将现有的类中的属性和方法进行进一步抽取，形成一个"父类"，同时其它类可以"继承"自这个类，使用关键字：extends。继承之后，子类将拥有可以被继承的成员变量和成员方法。继承的特点：java中只支持单继承，不支持多继承，但是Java中允许"多级继承"。但是不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( " is a " )关系。继承关系图：

class 学生{
		}
		class 教师{
		}
		class 班级{
			int 楼层；//自己的属性
			String 门牌号；//自己的属性
			学生[] stuArray = new 学生[80];//有学员
			教师 tea = new 教师();//有教师
		}
	3.组合关系：
		class 硬盘{
		}
		class 主板{
		}
		....
		class 电脑{//全部都是由其它类对象组成
			硬盘 yp = new 硬盘();
			主板 zb = new 主板();
			...
		}
	4.依赖关系：
		class 学生{
		}
		class 教师{
		}
		class 校长{//校长依赖于学生类和教师类，紧"耦合"
			void 谈话(学生 stu){
			}
			void 谈话(教师 tea){
			}
		}

*/
//人员类
class Personnel
{
	private String name;//姓名
	String sex;//性别
	int age;		//年龄
	
}
class Personnel2 extends Personnel
{
	void show(){
		System.out.println("大家好，我叫：" + name + 
							",性别：" + sex + 
							",年龄：" + age);
	}
}
class Student extends Personnel2{
	String classNo;	//学号
}
class Teacher extends Personnel{
	String subject;//学科
}
class Employee{
	String dept;	//部门
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		stu.name = "张三";
		stu.sex = "男";
		stu.age = 20;

		stu.show();

		Teacher tea = new Teacher();
		tea.name = "李四";
		tea.sex = "女";
		tea.age = 18;

		//tea.show();
	}
}

2.继承后子父类之间成员的关系

1）.成员变量

		class Fu{
			int num = 5;
		}

		class Zi extends Fu{
			int num = 20;
			
			
			public void show() {
				int num = 30;
				System.out.println("num:"+num);
				//当局部变量和成员变量重名的时候用this来区分
				System.out.println("this num:"+this.num);
				//当子类和父类出现了同名变量,用super来区分
				System.out.println("father num:"+super.num);
			}
		}

2）.成员方法

		class Fu {
			public void show() {
				System.out.println("fu show");
			}
			public void method() {}
		}

		class Zi extends Fu{
			
			public void show(){

				System.out.println("zi show");
			}
		}

3）.子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。

<final关键字>

 1.final表示最终的，可以修饰类、成员变量、成员方法；

  当被final修饰的类是最终类，不能被继承，被final修饰的成员变量是拥有最终值，只能被赋值1次，不能被修改，final的非static的变量，可以先声明后赋值，但只能在构造方法中赋值，而且只能被赋值一次，final的static的变量，必须要在声明时赋值；此值在运行时不允许修改。被final修饰的成员方法是最终的方法，不能被重写。

class Const{
	public static final double PI = 3.14159;
}
class Personnel{
	final int num;
	final static int num2 = 20;
	Personnel(){
		num = 10;
	}
	String name;
	final void say(){
		System.out.println("我是传智播客的一员");
	}
	
}
class Student extends Personnel{
	//不能重写父类的final方法
/*	void say(){
	}
	*/

}
class Demo 
{
	public static void main(String[] args) 
	{
		System.out.println(Const.PI);
	}
}

<抽象类>

1.抽象类，当一个方法不需要定义方法体，可以只有方法声明，此时，这个方法就是一个抽象方法，
 抽象方法，使用关键字：使用abstract关键字修饰，一个类中如果有一个抽象方法，那么这个类必须也被声明为abstract(抽象类)，一个类成为抽象类后，意味着：此类不能被实例化；就是用来被继承的；如果一个子类继承一个抽象类后，必须要重写父类的抽象方法。否则，子类也必须是抽象的；子类继承抽象类使用extends关键字，同样只能单继承；一个抽象类可以继承另一个抽象类。

2.模板模式

//抽象类用来定义一个模板；
abstract class A
{
}
abstract class Personnel
{
	//一个普通方法，子类会自动继承
	//就是一个模板方法
	void say(){
		System.out.println("我是传智播客的一名" + getType());
	}
	//让子类去实现的
	//基本方法
	abstract String getType();
}
class Student extends Personnel
{
	//重写父类的getType()
	String getType(){
		return "学生";
	}
}
class Teacher extends Personnel
{
	//重写父类的getType();
	String getType(){
		return "教师";
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		stu.say();

		Teacher tea = new Teacher();
		tea.say();
	}
}

3.抽象类中可以有抽象方法，可以有普通方法；也可以有普通的成员变量。然而抽象类中可以不包含抽象方法；也可以什么都不包含；
4.抽象关键字abstract不可以和哪些关键字共存？
  1).private :因为一个abstract方法需要被重写，所以不能修饰为private；
  2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
  3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；