・ Person类:name属性、age属性、setter、getter
・ Student类:name属性、age属性、school属性、setter、getter Student是一个人吧?Student 与Person类相比,发现只多了一个School属性。如果定义成两个类肯定是浪费的,至少Student类中的name 和age是无用的。我们可以把Student类作为Person类来处理。 class Person
{
String name;
int age;
public String getInfo()
{
return "姓名:"+this.name+",年龄:"+this.age;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
};
public class Demo01
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student() ;
// 以下的全部操作都是在Person类中定义的
s.name = "王乾" ;
s.age = 27 ;
System.out.println(s.getInfo()) ;
}
}; 哪怕子类没有增加任何新的东西,则至少也可以从父类继承来很多的内容。下面显示的就是Student类继承Person类调用getInfo()方法。
{
String name;
int age;
public String getInfo()
{
return "姓名:"+this.name+",年龄:"+this.age;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
String school;
};
public class Demo02
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student() ;
// 以下的全部操作都是在Person类中定义的
s.name = "王乾" ;
s.age = 27 ;
//在Student类中增加的school属性
s.school = "江南大学" ;
System.out.println(s.getInfo()+",学校:"+s.school) ;
}
}; 我们来验证一下哈,确实已经扩展了类滴功能哈,这就是继承的好处哈~
老头子 => 资产给孩子了 =>孩子可以通过老头子的钥匙|打开保险柜哈~ => 情书(保密的,私有的) => 保险柜 class Person
{
private String name;
private int age;
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
String school;
public void fun()
{
setName("王乾");
setAge(27);
}
public void print(){
System.out.println(getInfo()+",学校:"+school);
}
};
public class Demo03
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student() ;
}
};
我们发现没有报错哈,通过setter和getter方法,子类就可以继承父类的私有属性name和age
{
private String name;
private int age;
public Person()
{
System.out.println("*****父类的构造方法*****");
}
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
public Student()
{
System.out.println("*****子类的构造方法*****");
}
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
String school;
public void fun()
{
setName("王乾");
setAge(27);
}
public void print(){
System.out.println(getInfo()+",学校:"+school);
}
};
public class Demo04
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student() ;
}
};
我们看到Student s = new Student() ; 实例化对象时确实如此哈~~~
假设张三是李四的孩子,你说:如果现在连李四都没有,能有张三吗? 实际上子类在继承父类之前,必须确保父类所有东西都初始化完毕了,这样在子类的构造方法中就隐含了一个:super()的代码,此代码就表示调用父类中的构造方法。Super是一个关键字,在国外父类也称为超类(Superclass),所以把访问父类的操作称为super 我们在子类中加入代码super()来验证下 class Person
{
private String name;
private int age;
public Person()
{
System.out.println("*****父类的构造方法*****");
}
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
public Student()
{
super();
System.out.println("*****子类的构造方法*****");
}
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
String school;
public void fun()
{
setName("王乾");
setAge(27);
}
public void print(){
System.out.println(getInfo()+",学校:"+school);
}
};
public class Demo04
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student() ;
}
};
验证效果没有区别哈~
{
private String name;
private int age;
//希望在调用Person类的构造方法时可以直接为属性初始化
public Person(String name,int age)
{
System.out.println("*****父类的构造方法*****");
this.setName(name);
this.setAge(age);
}
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
public Student()
{
super();
System.out.println("*****子类的构造方法*****");
}
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
String school;
public void fun()
{
setName("王乾");
setAge(27);
}
public void print(){
System.out.println(getInfo()+",学校:"+school);
}
};
public class Demo05
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student() ;
}
};
这样修改后我们父类中就没无参构造方法了哈~现在我们运行下看下效果哈~提示找不到无参Person()方法。
{
private String name;
private int age;
//希望在调用Person类的构造方法时可以直接为属性初始化
public Person(String name,int age)
{
System.out.println("*****父类的构造方法*****");
this.setName(name);
this.setAge(age);
}
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
public Student(String name,int age,String school)
{
//这样隐含的代码super();写与不写没两样了哈~
//super();
//此时最好可以明确的指出要调用父类中的有两个参数的构造方法
//直接指明调用父类中有两个参数的构造方法。
super(name,age);
this.setSchool(school);
System.out.println("*****子类的构造方法*****");
}
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
private String school;
public void setSchool(String school)
{
this.school = school;
}
public String getSchool()
{
return this.school;
}
public void print(){
System.out.println(getInfo()+",学校:"+school);
}
};
public class Demo05
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student("王乾",27,"江南大学") ;
s.print();
}
}; 看下效果:
{
public void fun1()
{
System.out.println("Hello");
}
};
class B extends A
{
// 此方法覆写父类中的fun1()方法
public void fun1()
{
System.out.println("World~~~");
}
};
public class Demo06
{
public static void main(String args[])
{
B b = new B();
b.fun1();
}
}; 现在我们来看下b.fun1()是调用哪个方法哈~效果是b.fun1()是调用了子类B的fun1()方法后输出"World~~~"哈。
・ public > default(什么都不写) > private 如果我们把A类中fun1()方法的访问权限修改成default,则此时B类中fun1()方法的访问权限比A类大,程序应该没有问题,我们验证下哈~ class A
{
void fun1()
{
System.out.println("Hello");
}
};
class B extends A
{
// 此方法覆写父类中的fun1()方法
public void fun1()
{
System.out.println("World~~~");
}
};
public class Demo06
{
public static void main(String args[])
{
B b = new B();
b.fun1();
}
}; 验证效果正常,可以正常输出 如果我们把B类中fun1()方法的访问权限修改成default,则此时B类中fun1()方法的访问权限比A类小,则此时拥有比父类更严格的访问权限,程序应该异常,我们验证下效果哈~ class A
{
public void fun1()
{
System.out.println("Hello");
}
};
class B extends A
{
// 此方法覆写父类中的fun1()方法
void fun1()
{
System.out.println("World~~~");
}
};
public class Demo06
{
public static void main(String args[])
{
B b = new B();
b.fun1();
}
}; 现在程序编译时就报错哈~
{
private void fun1()
{
System.out.println("Hello");
}
public void fun()
{
fun1();
}
};
class B extends A
{
//此时相当于子类重新定义了一个方法fun1()
void fun1()
{
System.out.println("World~~~");
}
};
public class Demo06
{
public static void main(String args[])
{
B b = new B();
b.fun();
}
}; 验证下效果,现在输出的是字符串Hello哈~
{
private String name;
private int age;
//希望在调用Person类的构造方法时可以直接为属性初始化
public Person(String name,int age)
{
System.out.println("*****父类的构造方法*****");
this.setName(name);
this.setAge(age);
}
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
public Student(String name,int age,String school)
{
//这样隐含的代码super();写与不写没两样了哈~
//super();
//此时最好可以明确的指出要调用父类中的有两个参数的构造方法
//直接指明调用父类中有两个参数的构造方法。
super(name,age);
this.setSchool(school);
System.out.println("*****子类的构造方法*****");
}
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
private String school;
public void setSchool(String school)
{
this.school = school;
}
public String getSchool()
{
return this.school;
}
// 子类覆写了父类中的getInfo()方法
public String getInfo()
{
return "姓名:"+this.getName()+",年龄:"+this.getAge()+",学校:"+this.school;
}
};
public class Demo07
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student("王乾",27,"江南大学") ;
System.out.println(s.getInfo());
}
}; 现在我们验证下是否调用了复写的getInfo()方法,确实出现了哈~
{
private String name;
private int age;
//希望在调用Person类的构造方法时可以直接为属性初始化
public Person(String name,int age)
{
System.out.println("*****父类的构造方法*****");
this.setName(name);
this.setAge(age);
}
//私有属性要加入setter和getter操作就可以访问了哈~
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;
}
};
//Student类与Person类相比是扩充了Person类的功能,所以此处继承即可
class Student extends Person
{
public Student(String name,int age,String school)
{
//这样隐含的代码super();写与不写没两样了哈~
//super();
//此时最好可以明确的指出要调用父类中的有两个参数的构造方法
//直接指明调用父类中有两个参数的构造方法。
super(name,age);
this.setSchool(school);
System.out.println("*****子类的构造方法*****");
}
// 如果此处任何内容都不写,则至少应该与Person类的内容一致
private String school;
public void setSchool(String school)
{
this.school = school;
}
public String getSchool()
{
return this.school;
}
// 子类覆写了父类中的getInfo()方法
public String getInfo()
{
return super.getInfo()+",学校:"+this.school;
}
};
public class Demo07
{
public static void main(String args[])
{
// 使用子类对象
Student s = new Student("王乾",27,"江南大学") ;
System.out.println(s.getInfo());
}
}; 验证正常,在最大程度上达到了程序滴复写哈~~~
2、子类对象的实例化过程
3、方法的覆写
4、super关键字 #######################################################################
本文出自 “王乾De技术博客” 博客,谢绝转载!