class Demo4_Extends {
public static void main(String[] args) {
//System.out.println("Hello World!");
//Son s = new Son();
//Son s = new Son("s");
//s.show();
//s.print();
//Son s1 = new Son();
//s1.print(); //同父类同名的子类的成员方法
//s1.method();
//s1.print();
//System.out.println(s1.getName()+"..."+ s1.getAge());
//Son s2 = new Son("Son",1); //调用子类有参构造
Son s2 = new Son("Son"); //调用子类有参构造的重载
//System.out.println(s2.getName()+"..."+ s2.getAge());
}
}
/*
class Father{
public void show() {
System.out.println("父类");
}
}
class Son extends Father{
}
*/
/*
* 继承的注意事项
* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
* b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
* c:不要为了部分功能而去继承
* 项目经理 姓名 工号 工资 奖金
* 程序员 姓名 工号 工资
* 什么时候使用继承
* 继承其实体现的是一种关系："is a"。
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
*/
/*
class Father{
private String name; //私有成员变量无法继承
private void show() { //私有成员方法无法继承
System.out.println("父类");
}
}
class Son extends Father{
}
*/
/*
* 使用变量遵循一个“就近原则”。局部位置有就使用，没有就去本类的成员位置找，有就使用；没有就去父类的成员位置找，有就使用，没有就报错
* a:不同名的变量
* b:同名的变量
*/
/*
class Father{
int num1 = 10;
int num2 = 30;
}
class Son extends Father{
int num2 = 20;
public void print() {
System.out.println(num2); //就近原则,子类有就不用父类的
System.out.println(num1); //子类无就去继承父类的
System.out.println(num3); //父类也无,就报错
}
}
*/
/*
* this和super都代表什么
* this:代表当前对象的引用,谁来调用我,我就代表谁
* super:代表当前对象父类的引用
* this和super的使用区别
* a:调用成员变量
* this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
* super.成员变量 调用父类的成员变量
* b:调用构造方法
* this(...) 调用本类的构造方法
* super(...) 调用父类的构造方法
* c:调用成员方法
* this.成员方法 调用本类的成员方法,也可以调用父类的方法
* super.成员方法 调用父类的成员方法
*/
/*
class Father{
int num1 = 10;
int num2 = 30;
private int num3 = 50; //父类中私有成员变量
}
class Son extends Father{
int num2 = 20; //子类中同父类中同名的成员变量
public void print() {
int num2 = 40; //本类成员方法中的局部变量,this不会调用,this调用的是本类成员变量(成员方法外),本类无,加载父类,父类也无,就报错,不会调用方法中的局部变量
System.out.println(this.num2); //本类有时,this调用本类成员变量,this指代的是创建的Son类的对象
System.out.println(this.num1); //本类无时,this调用父类成员变量
System.out.println(super.num2); //本类有时,super仍调用父类成员变量
//System.out.println(super.num3); //即便用super也无法继承父类私有成员变量
}
}
*/
/*
* 子类中所有的构造方法(空参和有参)默认都会访问父类中空参构造方法
* 为什么呢?
* 因为子类会继承父类中的数据，可能还会使用父类的数据,所以，子类初始化之前，一定要先完成父类数据的初始化。
* 每一个构造方法的第一条语句默认都是：super();, Object类是最顶层的父类。
*/
/*
class Father{
public Father() {
//super(); //继承Object类
System.out.println("Father的空参构造方法");
}
public Father(String s) {
//super();
System.out.println("Father的有参构造方法");
}
}
class Son extends Father{
public Son() {
//super(); //这是一条语句,如果不写,系统会默认加上,用来访问父类中的空参构造
System.out.println("Son的空参构造方法"); //父类先完成初始化,子类再进行初始化
}
public Son(String s) {
//super();
System.out.println("Son的有参构造方法");
}
}
*/
/*
class Father{
private String name;
private int age;
public Father() {
System.out.println("Father的空参构造方法");
}
public Father(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Father的有参构造方法");
}
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 Son extends Father{
public Son() {
System.out.println("Son的空参构造方法");
}
public Son(String name,int age) {
System.out.println("Son的有参构造方法");
}
}
*/
/*
//父类中仅定义了有参构造,无空参构造时,子类直接继承时会报错
//由于定义了父类的有参构造,空参又未写,系统此时不会在父类中创建空参构造
class Father{
private String name;
private int age;
//public Father() {
// System.out.println("Father的空参构造方法");
//}
public Father(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Father的有参构造方法");
}
}
class Son extends Father{
public Son() {
System.out.println("Son的空参构造方法");
}
public Son(String name,int age) {
System.out.println("Son的有参构造方法");
}
}
*/
/*
//父类中无空参时super解决
class Father{
private String name;
private int age;
//由于定义了父类的有参构造,空参又未写,系统此时不会在父类中创建空参构造
public Father(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Father的有参构造方法");
}
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 Son extends Father{
public Son() {
//父类中无空参构造时可以通过super解决,法一:直接传值(不采用)
super("Son1",2); //super调用父类中的有参构造方法
System.out.println("Son的空参构造方法");
}
public Son(String name,int age) {
//父类中无空参构造时可以通过super解决,法二:传变量
super(name,sge);
System.out.println("Son的有参构造方法");
}
}
*/
//父类无空参时this解决
//this只能出现在子类的空参构造中,相当于调用子类中的有参构造,前提是子类中的有参构造可以调用父类中的有参构造
class Father{
private String name;
private int age;
//由于定义了父类的有参构造,空参又未写,系统此时不会在父类中创建空参构造
public Father(String name,int age) {
this.name = name;
this.age = age;
System.out.println("Father的有参构造方法");
}
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 Son extends Father{
//public Son() {
//父类中无空参构造时可以通过this控制
// this("Son2",3); //this调用本类中的有参构造方法
//super("Son2",3); //super调用父类中的有参构造方法
//super(); //默认有super();会去继承父类空参构造,而父类中无空参构造,故会报错
// System.out.println("Son的空参构造方法");
//}
//有参构造重载
public Son(String name) {
//this(name,4); //this调用本类中的有参构造方法
super(name,5); //super调用父类中的有参构造方法
System.out.println("Son的有参构造方法");
}
public Son(String name,int age) {
//super();
//this("Son3",4); //this不该出现于此,错误: 递归构造器调用,子类去创建对象时,子类的构造方法(无参或有参),必须访问父类的空参构造方法
//this(name,age);
super(name,age); //目的是将系统默认super();覆盖
System.out.println("Son的有参构造方法");
}
//public Son(String name,int age) {
// this("Son3",4); // this不该出现于此,错误: 递归构造器调用,子类去创建对象时,子类的构造方法(无参或有参),必须访问父类的空参构造方法
// super(name,age);
// System.out.println("Son的有参构造方法");
//}
//上面的代码相当于以下代码块,super();会访问父类的空参构造,而父类中只有有参构造,故会报错
//public Son(String name,int age) {
// super();
//this("Son3",4); // 错误: 递归构造器调用,子类去创建对象时,子类的构造方法(无参或有参),必须访问父类的空参构造方法
//super(name,age);
// System.out.println("Son的有参构造方法");
//}
}
/*
class Father{
public void print() {
System.out.println("父类成员方法");
}
}
class Son extends Father{
public void method() {
System.out.println("子类成员方法");
}
public void print() {
super.print(); //super调用父类同名成员方法
this.method(); //this调用本类成员方法
System.out.println("同父类成员方法同名的子类成员方法");
}
}
*/
|
|
收藏
淘帖
踩
