java面向对象特性-继承

发表于
  • Java用extends关键字表示继承关系

    当创建一个类是,总是在继承,如果没有明确指出要继承的类,就总是从跟类Object进行继承

1
2
3
4
5
6
7
8
9
class People{
	public People(){
	}
}

class Man extens Peopele{
	public man(){
	}
}
  • 子类访问权限
    1. 子类不能继承父类的private成员方法,就相当于你爸把钥匙藏了,子类访问不了,因为你爸不给你钥匙,钥匙=访问权限
    2. 父类protected成员方法
      1. 在同一个包下 == 默认包访问权限
      2. protected 在跨包只能是父子关系子类可以访问父类 用protected 修饰的成员变量和方法 ()
  • 子类调用父类的成员方法和成员变量
    在Java中用super来引用父类的成分
    1. super.成员变量/super.成员方法;
      主要在子类中调用父类的同名变量或者方法
      2.super (parameter1 .parameter2 …)
      在子类中显式地调用父类的构造方法,默认调用的是super() ;是无参构造的 .
  • 父类与子类的初始化顺序 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    public class extend {
        static class p {
            p() {
                System.out.println("farher" + "的静态变量");
            }
        }
        static class S {
            S() {
                System.out.println("son的静态变量");
            }
        }
        static  class get{
            get(){
                System.out.println("father的实例变量");

            }    }
            static class put{
            put(){
                System.out.println("son的实例变量");
            }
            }
        static class father {
            static p a = new p();
            get b = new get();

            father() {
                System.out.println("father的构造方法");
            }

            static {
                System.out.println("father静态块");
            }

            {
                System.out.println("father实例块");
            }
            public void add() {
                System.out.println("father的普通方法");
            }

        }
        static class son extends father {
            static S b = new S();
                put a = new put();
            son() {
                System.out.println("son的构造方法");
            }

            static {
                System.out.println("son静态块");
            }

            {
                System.out.println("son实例块");
            }

            public void print() {
                System.out.println("son的方法");
            }

        }
        public static void main(String[] args) {
            son s = new son();
            s.print();
        }
    }

结果为:
在这里插入图片描述
所以初始化顺序为:

  1. 父类(静态变量,块)
  2. 子类(静态变量,块)
  3. 父类(实例变量,实例块,构造方法)
  4. 子类(实例变量,实例块,构造方法)
  • 重写(override)
  1. 继承关系,发生在父子类中,在子类中最父类的方法进行重写
  2. 方法名 参数名必须相同
  3. 访问修饰符范围大于等于父类,不能重写父类中
  4. 访问修饰符private修饰的方法
  5. 返回值范围小于等于父类，抛出的异常范围小于等于父类

    重写的原理:在方法区中将父类的原来的方法覆盖了

  • 重载
  1. 发生在同一个类中
  2. 方法名必须相同
  3. 参数类型不同,个数不同,顺序不同,方法返回值和访问子UShi服可以不同,发生在编译时
  • final 关键字
    • 修饰的类不能被继承
    • 修饰的类不能被重写
    • 修饰的变量不能改变