第1章继承

男娘i 2022-01-11 10:27 303阅读 0赞

1.1 继承的概述  
在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。  
1.2 继承的格式&使用  
在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

格式：  
class 子类 extends 父类 \{\}  
1.2.1 案例代码一:

package com.itheima_01;
    /*
     * 继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。
     * extends
     *
     */
    public class ExtendsDemo {
    public static void main(String[] args) {
    DotA1 d = new DotA1();
    d.start();
    LOL1 l = new LOL1();
    l.start();
    }
    }
    
    class Game1 {
    String name;
    double version;//版本号
    String agent;//代理商
    public void start() {
    System.out.println("游戏启动了");
    }
    public void stop() {
    System.out.println("游戏关闭了");
    }
    }
    
    class DotA1 extends Game1 {
    /*String name;
    double version;//版本号
    String agent;//代理商
    public void start() {
    System.out.println("游戏启动了");
    }
    public void stop() {
    System.out.println("游戏关闭了");
    }*/
    }
    
    class LOL1 extends Game1 {
    /*String name;
    double version;//版本号
    String agent;//代理商
    public void start() {
    System.out.println("游戏启动了");
    }
    public void stop() {
    System.out.println("游戏关闭了");
    }*/
    }

1.3 继承的特点  
在类的继承中，需要注意一些问题，具体如下：  
1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

class A{}
         class B{}
         class C extends A,B{}  // C类不可以同时继承A类和B类

2、多个类可以继承一个父类，例如下面这种情况是允许的。

class A{}
    class B extends A{}
    class C extends A{}   // 类B和类C都可以继承类A

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。

class A{}
    class B extends A{}   // 类B继承类A，类B是类A的子类
    class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类  
1.3.1 案例代码二  
1.4 继承中成员变量的特点  
A:子类只能获取父类非私有成员  
子父类中成员变量的名字不一样直接获取父类的成员变量  
子父类中成员变量名字是一样的获取的是子类的成员变量

B:就近原则：谁离我近我 就用谁  
如果有局部变量就使用局部变量  
如果没有局部变量，有子类的成员变量就使用子类的成员变量  
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量  
C: super:可以获取父类的成员变量和成员方法,用法和this是相似的  
1.4.1 案例代码三

package com.itheima_01;
    /*
     * 继承中成员变量的特点
     * 子类只能获取父类非私有成员
     * 子父类中成员变量的名字不一样直接获取父类的成员变量
     * 子父类中成员变量名字是一样的获取的是子类的成员变量
     *
     * 就近原则：谁离我近我就用谁
     * 如果有局部变量就使用局部变量
     * 如果没有局部变量，有子类的成员变量就使用子类的成员变量
     * 如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量
     * 啥都没有，出错了！！！
     *
     * super:可以获取父类的成员变量和成员方法,用法和this是相似的
     */
    public class ExtendsDemo3 {
    public static void main(String[] args) {
    Kid3 k = new Kid3();
    k.show();
    }
    }
    
    class Dad3 {
    String name = "建霖";
    }
    
    class Kid3 extends Dad3 {
    String name = "四葱";
    public void show() {
    String name = "五葱";
    System.out.println(super.name);
    System.out.println(this.name);
    System.out.println(name);
    }
    }

1.5 继承中成员方法的特点&方法重写  
1.5.1 案例代码四  
A:子类中没有这个方法,调用父类的

package com.itheima_01;[/font][/align][font=微软雅黑]/*
     * 继承中成员方法的特点
     * 子类中没有这个方法，调用父类的
    
     */
    public class ExtendsDemo4 {
    public static void main(String[] args) {
    Kid4 k = new Kid4();
    k.eat();
    }
    }
    
    class Dad4 {
    public void eat() {
    System.out.println("小酌两口");
    System.out.println("去睡觉了");
    }
    }
    
    class Kid4 extends Dad4 {
    
    }

1.5.2 案例代码五  
B: 子类中重写了这个方法，调用子类的  
方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法

package com.itheima_01;[/font][/align][font=微软雅黑]/*
     * 继承中成员方法的特点
     * 子类中没有这个方法，调用父类的
     * 子类中重写了这个方法，调用子类的
     *
    方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法
             方法的重载：在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关
    
     */
    public class ExtendsDemo4 {
    public static void main(String[] args) {
    Kid4 k = new Kid4();
    k.eat();
    }
    }
    
    class Dad4 {
    public void eat() {
    System.out.println("小酌两口");
    System.out.println("去睡觉了");
    }
    }
    
    class Kid4 extends Dad4 {
    public void eat() {
    System.out.println("好好吃饭");
    }
    }

1.6 方法重写的应用场景&注意事项  
方法重写的应用场景：当父类的方法不能完全满足子类使用的时候，既可以保留父类的功能（沿袭、传承），还可以有自己特有的功能  
方法重写的注意事项：  
不可以重写父类私有的成员方法，压根就看不到父类的私有成员  
子类重写父类方法，权限必须大于等于父类方法的权限  
注解  
@Override：方法重写，说明下面的方法是重写父类的方法  
1.6.0.1 案例代码六

package com.itheima_03;
    /*
     * 方法重写的应用场景：当父类的方法不能完全满足子类使用，这个时候子类重写父类的方法，
     *     并可以在方法中使用关键字super调用父类的方法，这样做即可以保有父类的功能，也可以拥有子类特有的功能
     *  方法重写的注意事项：
     *            不能重写父类私有的方法
     *           权限必须大于等于父类方法的权限
     * 
     *  注解：@
     * 
     */
    public class ExtendsDemo5 {
    public static void main(String[] args) {
    NewPhone np = new NewPhone();
    np.call();
    }
    }
    
    class Phone {
    void call() {
    System.out.println("打电话");
    }
    }
    
    class NewPhone extends Phone {
    @Override
    public void call() {
    System.out.println("录音");
    //System.out.println("打电话");
    //super.call();
    }
    }

1.7 继承中构造方法的执行顺序  
A:super(实参列表);语句 在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用  
B:this(实参列表); 语句 在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用  
1.7.1 案例代码七

package com.itheima_01;

/\*

*  继承中构造方法的执行顺序
 *  在子父类中，创建子类对象，调用子类的构造方法，
 *  在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造，则默认调用父类无参构造
 *  为什么要调用父类构造？
 *  因为需要给父类的成员变量初始化
 *  肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码
 *  
 *  我是父类无参构造 --- 我是子类有参构造 --- 我是子类无参构造  
    \*/  
    public class ExtendsDemo6 \{  
    public static void main(String\[\] args) \{  
    //Die d = new Die();  
    Zi6 z = new Zi6();  
    \}  
    \}

class Die6 \{  
public Die6() \{  
System.out.println("我是父类无参构造");  
\}  
public Die6(int num) \{  
System.out.println("我是父类有参构造");  
\}  
\}

class Zi6 extends Die6 \{  
public Zi6() \{  
//super(1);  
//super();  
this(1);//不会再调用父类的无参构造了  
System.out.println("我是子类无参构造");  
\}  
public Zi6(int num) \{  
//会默认调用父类无参构造  
System.out.println("我是子类有参构造");  
\}  
\}  
1.8 this与super区别  
1.8.1 案例代码八:

package com.itheima_01;
    /*
     * this和super的区别
    this:当前对象的引用
    调用子类的成员变量
    调用子类的成员方法
    在子类的构造方法第一行调用子类其他构造方法
    super:子类对象的父类引用
    调用父类的成员变量
    调用父类的成员方法
    在子类的构造方法第一行调用父类的构造方法
     */
    public class ExtendsDemo7 {
    public static void main(String[] args) {
    Zi z = new Zi();
    z.function();
    }
    }
    
    class Die {
    int num = 10;
    public Die() {
    System.out.println("我是父类无参构造");
    }
    public Die(int num) {
    System.out.println("我是父类有参构造");
    }
    public void method() {
    System.out.println("我是父类的方法");
    }
    }
    
    class Zi extends Die {
    //int num = 30;
    public Zi() {
    //this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
    super();
    System.out.println("我是子类无参构造");
    }
    public Zi(int num) {
    System.out.println("我是子类有参构造");
    }
    public void method() {
    System.out.println("我是子类的方法");
    }
    public void function() {
    //this.num = 50;
    //System.out.println(num);
    //this.method();
    //super.num = 40;
    //super.method();
    System.out.println(this.num);
    }
    }

转载于:https://blog.51cto.com/13517854/2092928