Demo9_继承进阶

package test02;

public class Demo9_ExtendsMax {
public static void main(String[] args)
{
//Zi z =new Zi();
//z.show();
Worker1 w =new Worker1(“lisi”,22);
w.work();
}
}
//继承出现后在代码中的体现
//1.成员变量
/*
*特殊情况：
* 子类中定义了一模一样的成员变量
* 都存在于子类对象中
*如何在子类中直接访问同名的父类中的变量呢
*通过super完成
*
*super和this用法
*
*this 代表本类对象的引用（可单独用）
*super 代表父类的内存空间（只能配合“.”用）
*/
//2.成员函数
/*
*特殊的情况：
* 父类子类中的定义了一模一样的函数
* （运行结果）子类在运行
* 这种情况在父子类中，是函数的另一种特性 override(重写，覆盖，复写)
*
* 重写什么时候用？
* 举例：
*描述手机：
*class Phone
*{
//来电显示
* void show()
* {
* sop(“dianhuahaoma”);
* sop(“asas”);
* sop(“asasasadassd”);
* }
* }
* Phone p = new Phone();
* p.show();
*
* 随着电话的升级，可能显示其他功能
* 修改源码，虽然可以解决问题但是工作量比较大，不利于后期的维护与拓展
* 为了拓展方便单独描述单独封装，新电话也是电话的一中，继承，直接获取父类中的功能
* 但是新电话的功能已经发生了变化。需要重新定义
*
* 那么定义一个新功能合适吗？
* 比如newshow，
* 不合适；因为父类已经将来电显示功能定义完了，
* 子类不需要重新定义新功能，直接用就可以了，如果子类的来电显示功能内容不相同
* 只需要保留来电显示功能定义子类的内容即可，这就是重写的应用
* class NewPhone extends Phone
* {
* void show()
* {
* super.show();//直接调用父类方法
* sop(“sdsdasdas”);
* sop(“dsadbghssa”);
* }
* }
*
*
* 重写的注意事项
*
* 1.子类覆盖父类，必须保证全要大于或等于父类权限
* public private（只能在本类中使用）默认的
*
* 2.静态覆盖静态
*写法上注意：上下必须一致，必须都是静态
*
*
* 子父类中的构造函数的特点
* 当子父类都有构造函数时，先执行父类的构造函数在执行子类的构造函数
* 因为所有子类构造函数的第一行都有一句隐式语句super();默认调用父类中的空参数构造函数
*
*
* 为什么会有这一句super();
*
* 子类会继承父类中的内容，所以子类在初始化时，必须到父类中去执行父类的初始化操作才能更方便的使用父类中的内容。

*public static void main(String[] args)
* {
* new Zilei(6);
* }
* class FuLei
{

            void show()
            {
                System.out.println("fulei show run");
            }
        }
        class Zi extends FuLei
        {
            void show()
            {
                System.out.println("zilei show run");
            }
        }
        当父类中没有空参数构造函数时，子类中的构造函数必须同构显示的super();语句指定要访问的父类中的构造函数

*
*public static void main(String[] args)
* {
* new Zilei();
* }
* class FuLei
{

            Fu(int x)
            {
                System.out.println("fulei show run...."+x);
            }
        }
        class Zilei extends FuLei
        {
            Zi(int x)
            {
                 super(x);//super();访问父类中默认的空参数函数super(x);访问Fu(int x);
                System.out.println("zilei show run...."+x);
            }
        }

//细节
*1. 如果子类中的构造函数第一行写了一个this调用了本类的其他构造函数（至少有一个含有隐式super();）那么super调用父类的语句还有吗？
* 没有。因为this();或者是super();只能定义在构造函数的第一行，（为什么要定义在第一行）因为初始化时要先执行

*2.父类构造函数是否含有隐式的super呢？
*也有。只要是构造函数默认第一行都是super();
*父类的父类是谁呢？super到底是调用的谁的构造函数呢？
*Java体系在设计时，定义了一个所有对象的父类Object
*可以在父类的后面加 extends Object 子类不直接继承Object
*
*
*/
//3.构造函数
//class FuLei
//{
// //int num1=3;
//// int num = 3;
// void show()
// {
// System.out.println(“fulei show run”);
// }
//}
//class Zi extends FuLei
//{
// //int num2=4;
//// int num=4;
// void show()
// {
// System.out.println(“zilei show run”);
// //System.out.println(“num1=”+num1);
// //System.out.println(“num2=”+num2);
//// System.out.println(“num=”+this.num);//num代表子类的num
//// System.out.println(“num=”+super.num);//num代表父类的num
// }
//}
class Person123
{
private String name ;
private int age ;
public Person123(String name,int age)
{
this.name=name;
this.age=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 Student1234 extends Person123
{
public Student1234(String name,int age)
{
super(name,age);
}
void study()
{
System.out.println(“haohao”);
}
}
class Worker1 extends Person123
{
public Worker1(String name,int age)
{
super(name,age);//必须手动明确调用对象
}
void work()
{
System.out.println(“A+B”);
}
}

猜你喜欢