java 继承的基本实现

时间：2015-04-24 12:38:56 阅读：180 评论：0 收藏：0 [点我收藏+]

标签：java

继承的基本实现类的继承格式

在java中使用extends关键字完成类的继承关系，操作格式如下：

class 父类{}
class 子类 extends 父类{}

继承父类的功能，扩展子类的所有功能。

[java] view plain copy print ?

class Person{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public void setInt(int age){
this.age = age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
class student extends Person{
//此处不添加任何代码
}
public class ExtDemo02{
public static void main(String args[]){
Student stu = new Student();
stu.setName("张三");
set.setAge(30);
System.out.println(stu.getName()+stu.getAge());
}
}

子类有时候也称之为派生类。

继承的进一步研究

子类对象的实例化过程

实例化子类对象：
1.先调用父类的构造->调用父类构造
2.再调用子类构造->调用子类构造

实例：

InstanceDemo.java

[java] view plain copy print ?

class Person{
private String name;
private int age;
public Person(){
System.out.println("父类Person中的构造方法");
}
public void setName(String name){
this.name = name;
}
public void setInt(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(){
System.out.println("子类student中构造");
}
}
public class InstanceDemo{
public static void main(String args[]){
Student stu = new Student();
}
}

//输出：父类Person中的构造
子类Student中的构造

实际上此时隐含在Student的构造方法的第一行有以下代码：
super(); //调用父类的构造函数
即代码相当于：

[java] view plain copy print ?

class Person{
private String name;
private int age;
public Person(){
System.out.println("父类Person中的构造方法");
}
public void setName(String name){
this.name = name;
}
public void setInt(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("子类student中构造");
}
}
public class InstanceDemo{
public static void main(String args[]){
Student stu = new Student();
}
}

注意点：在方法覆写时必须考虑到权限问题,即：被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
访问权限一共有四种，现在只讲三种：
●private:只能被类内访问，权限最第
●default:相当于什么都不声明
●public:最大的访问权限
●大小关系：private<default<public

如果降低了访问权限时如Person使用public而Student使用default时，会产生以下错误：
print() in Student cannot override print() in Person; attempting to assign weaker access privileges; was public void print()
//表示错误的，降低了权限

子类会自动调用覆写的方法，但此时如果非要调用父类中的方法的话，使用super()关键字。
如:Student构造方法调用父类的方法可以进行以下修改：

[java] view plain copy print ?

class Person{
private String name;
private int age;
public Person(){
System.out.println("父类Person中的构造方法");
}
public void setName(String name){
this.name = name;
}
public void setInt(int age){
this.age = age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public void print(){
System.out.println("just a moment!");
}
}
class Student extends Person{
private String school;
public Student(){
super.print();
System.out.println("子类student中构造");
}
}
public class InstanceDemo{
public static void main(String args[]){
Student stu = new Student();
}
}

---------------------------------------------------------
问题：如果现在在父类中使用private 关键字声明了一个方法，那么在子类中使用default权限算是覆写吗？
答：不是覆写.
------------------------------------------------------

[java] view plain copy print ?

class Person{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public void setInt(int age){
this.age = age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
private void print(){
System.out.println("Person------>void print()");
}
}
class Student extends Person{
private String school;
void print(){
System.out.println("Student-------->void print()");
}
}
public class InstanceDemo{
public static void main(String args[]){
Student stu = new Student();
stu.print();
}
}

输出：Student---------->void print()

此时，方法没有被覆写，而是相当于在子类中又重新定义了一个新的方法出来。

3.3 属性的覆写

在子类中声明了父类同名的属性。

[java] view plain copy print ?

class Person{
public String name;
private int age;
public void setName(String name){
this.name = name;
}
public void setInt(int age){
this.age = age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
private void print(){
System.out.println("Person------>void print()");
}
}
class Student extends Person{
public String name;
void print(){
System.out.println("父类中的属性："+super.info);
System.out.println("子类中的属性："+this.info);
}
}
public class OverrideDemo{
public static void main(String args[]){
Student stu = new Student();
stu.print();
}
}

3.4方法的覆写与的方法的重载

overloading                   overrideing
方法名称相同参数的类型或个数不同       方法名称参数的类型返回值类型全部相同
对权限没有要求                   被覆写的方法不能拥有更严格的权限
发生在一个类中                   发生在继承类中

3.5   super关键字
表示从子类调用父类中的指定操作，例如调用属性，方法，构造等。因为在子类实例化的时候会默认调用父类中的无参构造，如果现在希望调用有参构造方法，可以使用super方法传递参数。

[java] view plain copy print ?

class Person{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("父雷Person中的构造方法");
}
public void setName(String name){
this.name = name;
}
public void setInt(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(String name,int age,String school){
super(name,age);
this.school = school;
System.out.println("子类student中的构造方法");
}
}
public class OverrideDemo{
public static void main(String args[]){
Student stu = new Student("张三",30,"山东大学");
}
}

当子类调用无参构造方法时，父雷中不存在无参构造方法，此时就会报错。因为子类会在无参构造方法第一行隐含调用super方法，解决方法为：父类定义一个无参构造方法，或使用super调用父类存在参数的方法。

不管任何时候，子类实例化时候先去调用父类中的构造方法，默认调用无参构造。

总结：
使用 super 调用无参方法
1.建立含无参构造的类。
2.建立含无参构造子类，继承父类。
3.子类中构造第一行添加或不添加super

使用 super 调用含参数的方法
1.建立含参构造的类。
2.建立含参子类（覆写构造函数），继承父类。
3.子类中构造第一行添加super(内部参数同父类构造方法)

this与super的区别

this                                   super
属性访问：访问本类中的属性，如果本类没有这些属性则从父类中查找。   属性访问：访问父类中的属性
方法：访问本类中的方法，如果本类没有则从父类中查找。           方法：直接访问父类中的方法
调用构造：调用本类构造，必须放在构造方法首行。               调用构造：调用父类构造，必须放在子类构造方法的首行。
特殊：表示当前对象。                           特殊：无此概念

对于this和super本身都可以调用构造方法，而且调用的时候都必须放在构造方法首行，所以两个关键字不能同时出现。

疑问：如果在构造方法中（子类）使用了this，那么是不是就不调用父类中的构造方法？

答：子类中不可能同时都调用this()方法，所以默认仍会调用父类的构造方法。

java 继承的基本实现

标签：java

原文地址：http://blog.csdn.net/sqc3375177/article/details/45243879

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行