面向对象高级(继承的基本实现、进一步研究、final关键字)

继承的基本实现

类的继承格式：
在java中使用extends关键字完成类的继承关系，操作格式：
·class 父类{ }; //定义父类
·class 子类 extends 父类{ }; //使用extends关键字实现继承

class Person		//定义人类
{
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
class student extends Person     //使用extends关键字继承Person类
{
private String school;	//student自己的属性
public void setSchool(String school){
this.school=school;
}
public String getSchool(){
return school;
}
}
public class ExtDemo01
{
public static void main(String args[]){
student stu=new student();
stu.setName("张三");	//student类具有Person类(父类)的属性
System.out.println(stu.getName());
stu.setSchool("长垣一中");	//stu类独有的属性
System.out.println(stu.getSchool());
}
}

子类同时具有其父类的属性，可以直接进行使用，也能具有自己的属性。继承就是子类继承父类，可以扩展已有类的功能。

继承的限制

在java中只允许单继承，不能使用多重继承，即：一个子类只能继承一个父类。但是允许进行多层继承，即：一个子类可以有一个父类，一个父类还可以有一个父类。



多层继承代码实现：

class A
{
private String name;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
}
class B extends A
{
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
class C extends B
{
private String school;
public void setSchool(String school){
this.school=school;
}
public String getSchool(){
return school;
}
}
public class ExtDemo02
{
public static void main(String args[]){
C c=new C();
c.setName("张三");
c.setAge(20);
c.setSchool("长垣一中");
System.out.println("姓名是 ："+c.getName()+"年龄是："+c.getAge()+"所在学校："+c.getSchool());
}
}

访问限制：

在使用继承的时候应注意：子类不能直接访问父类中的私有成员，但是子类可以调用父类的非私有方法。简单来说父类中实现了属性的封装，然后在子类中应该使用set或get方法对父类中的私有成员进行访问。
如以下代码：

class Person{					// 定义Person类
private String name ;		// 定义name属性
private int 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 ;
}
};
class Student extends Person{					// 定义Student类
public void fun(){
System.out.println("父类中的name属性：" +name) ;	// 错误，无法访问
System.out.println("父类中的age属性：" +getAge() ) ;	// 正确，同过调用方法获得
}

};
public class ExtDemo03
{
public static void main(String args[]){
Student stu=new Student();
stu.fun();
}
}

继承的进一步研究

子类对象的实例化过程：

在继承的操作中，对于子类对象的实例化也是有要求的。即：子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自己的构造方法。如图所示：



如以下代码：

class Person{					// 定义Person类
public Person(){
System.out.println("父类中的构造方法");
}
};
class Student extends Person{					// 定义Student类
public Student(){
super();		//默认的会执行此语句 该语句被隐藏 父类没有参数的构造方法
System.out.println("子类中的构造方法");
}
};
public class ExtDemo04
{
public static void main(String args[]){
Student stu=new Student();	//实例化子类对象
//程序输出：
//父类中的构造方法
//子类中的构造方法
}
}

当在父类中声明了有参数的构造方法时，则必须要手动创建无参的构造方法，或者是调用父类中有参数的构造方法。
如下代码是调用父类中有参数的构造方法：

class Person{					// 定义Person类
private String name;
public Person(String name){
System.out.println("父类中name属性："+name);
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
};
class Student extends Person{					// 定义Student类
private int age;
public Student(String name,int age){
super(name);
System.out.println("子类中的age属性："+age);
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
};
public class ExtDemo05
{
public static void main(String args[]){
Student stu=new Student("张三",20);	//实例化子类对象
//程序输出
//父类中name属性：张三
//子类中的age属性：20
}
}

方法的覆写

方法的覆写就是指子类中定义了与父类中同名的方法，但是在方法的覆写的时候必须考虑到权限的问题：被子类覆写的方法不能拥有比父类方法中更加严格的访问权限。
访问权限：private < default < public public的访问权限最高
所以：如果在父类中定义了public方法，子类的访问权限必须是public，否则程序会出错。
以下代码父类中方法访问权限为默认，子类覆写父类的方法权限是public，如果覆写的方法访问权限<父类中方法的访问权限，则程序会出现错误。

class Person{					// 定义Person类
void print(){
System.out.println("父类中的默认权限方法");
}
};
class Student extends Person{					// 定义Student类
public void print(){	//方法的覆写 与父类中方法名称相同
System.out.println("子类中public权限的方法");
}
};
public class ExtDemo06
{
public static void main(String args[]){
Student stu=new Student();	//实例化子类对象
stu.print();	//如果子类中没有定义print方法，则会调用父类中的方法
//程序输出
//子类中public权限的方法
}
}

如果在子类想要方法父类中的方法，则通过super关键字即实现，格式为super.方法( );

方法的覆写与重载的区别

此知识点较为重要，面试题会经常遇到。

final关键字

·final在java中表示的是最终的意思，也可以称为完结器。
·可以使用final关键字声明类、属性、方法但是应符合以下几点：
1、 使用final声明的类不能有子类。
2、 使用final声明的方法不能被子类覆写。
3、 使用final声明的变量称为常量，常量是不能被修改的，而且常量必须在声明时为其明确的指定内容，即：值。此时注意：常量名是需要大写的。
全局常量：
·使用static final关键字联合声明的变量称为全局常量。
·例：public static final int pi=3.14
在一般的开发中，使用final定义常量是最多的，用static声明的内容是所有对象所共同拥有。