Java基础复习-04

面向对象特征-1

1.继承
1.1.关于继承的限制。
首先不能实现多继承，一个类不能继承两个类，但是可以实现间接多继承。比如B类继承自A类，C类继承自B类。
其次子类不能继承父类的私有属性或者方法，只能继承全部的共有操作。

1.2.子类的构造方法
假设代码如下：

class Person{
	private String name ;
	private int age ;
	public Person(){
		System.out.println("******************") ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
};
class Student extends Person {
	private String school ;	// 扩充的属性
	public Student(){
		super() ;	// 隐藏了此语句
		System.out.println("===================") ;
	}
	public void setSchool(String school){
		this.school = school ;
	}
	public String getSchool(){
		return this.school ;
	}
};
public class ExtDemo07{
	public static void main(String args[]){
		Student stu = new Student() ;	//  学生
	}
};

其执行结果为：

******************
===================

以上先执行了父类的构造方法，之后才调用了子类的构造方法。在实例化子类的时候，要先实例化父类，为父类初始化。

1.3.方法覆写
方法的覆写是发生在继承关系中，子类覆写父类同名的方法。
访问权限的限制：被覆写的方法不能比子类中的方法更严格的访问权限，换句话就是，一个方法被覆写，其访问权限不能被缩小。原本是public的方法，覆写后子类的方法只能是public的权限。
子类调用方法时，如果该方法被覆写过，永远调用的是被子类覆写过的方法。
代码如下：

class A{
	private void fun(){
		System.out.println("A类中定义的方法。") ;
	}
	public void print(){
		this.fun() ;		// 调用fun()方法
	}
};
class B extends A {
	void fun(){	// 此方法实际上属于新建的一个方法
		System.out.println("B类中定义的方法。") ;
	}
};
public class OverrideDemo03{
	public static void main(String args[]){
		B b = new B() ;
		b.print() ;
	}
};

执行结果为：

  B类中定义的方法。

隐申：如果父类的一个方法A使用private的访问权限，子类中的方法A使用了default的访问权限，则不是覆写方法，因为private父类中的私有方法，子类不能继承过来。如果希望调用父类中被覆写过的方法，则只能使用super.方法名()进行调用。
引申：属性也可以被覆写

1.4. 方法重写的使用
见代码：

class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public String getInfo(){
		return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
class Student extends Person {
	private String school ;	// 扩充的属性
	public Student(String name,int age,String school){
		this(name,age) ;	// 明确调用父类中有两个参数的构造方法
		this.school = school ;
	}
	public Student(String name,int age){
		super(name,age) ;
	}
	public String getInfo(){
		return super.getInfo() + "；学校：" + this.school ;
         }
	public void setSchool(String school){
		this.school = school ;
	}
	public String getSchool(){
		return this.school ;
	}
};
public class ExtDemo10{
	public static void main(String args[]){
		Student stu = new Student("张三",30,"清华大学") ;	//  学生
		System.out.println(stu.getInfo()) ;
	}
};

关键是子类getInfo方法，可以通过super关键字，调用父类以实现的部分内容。

2.两个重要比较。
2.1.重载与重写的比较，见下图。
[img]http://dl.iteye.com/upload/attachment/439273/435a22d8-60a7-3277-b578-c089ebc7227c.jpg[/img]
2.2.this与super的比较，见下图。
[img]http://dl.iteye.com/upload/attachment/439275/bb2b2883-5963-3312-962b-a59724153e5d.jpg[/img]

3.final关键字
final关键字有以下作用：
1.声明类：声明的类不能有子类。
2.声明方法：声明的方法不能被子类所覆写。
3.声明变量：声明的变量就成为常量，常量是不可以修改的。