面向对象之继承基础知识 方法重写 & 修饰符&代码块

1.继承概念 格式 优缺点

1.1概念

继承是面向对象三大特征之一，可以使子类具有父类的属性和方法，还可以在子类中重新定义 追加属性和方法

1.2 格式

public class 子类名 extends 父类名{} 父类也称为基类，超类 子类也叫做派生类

1.3优缺点

好处：提高代码的复用性 维护性 弊端：继承让类与类产生了关系，类的耦合性增强了 削弱了子类的独立性
什么时候用继承： 满足关系： a is b ：苹果，梨子 is 水果

2.继承中变量的访问特点

2.1 在子类成员方法中访问一个变量，首先会在子类局部范围(成员方法内部)找–>子类成员变量范围找–>父类成员变量范围找–>都没有就报错
2.2 要想在本类成员方法中访问到本类的成员变量：用this.成员变量 要想访问到父类的成员变量，用super.成员变量
2.3 this 代表本类对象的引用 super代表的是父类对象的引用 this super他们都可以各访问到本类 父类的成员变量 成员方法 构造方法

public class Fu {
    int age = 10;
}
public class Zi extends Fu{
    int age = 20;
    public void show(){
        int age = 30;
        System.out.println(age);  //30
        System.out.println(this.age); //访问本类的成员变量//20
        System.out.println(super.age);//访问父类的成员变量//10
    }

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
  }
}

3.继承中成员方法的访问特点

3.1 通过子类对象访问一个方法，子类成员范围找–>父类成员范围找–>如果没有报错

public class Fu {
    public void show(){
        System.out.println("fu类show方法被调用");
    }
}
public class Zi extends Fu{
   public void method(){
       System.out.println("Zi类method方法被调用");
   }
    public void show(){
       super.show();
       System.out.println("zi类show方法被调用");
    }
}
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();//Zi类method方法被调用
        z.show();
                   //fu类show方法被调用   //因为子类继承父类  所以子类是可以调用父类的方法
                   //zi类show方法被调用   //要是子类有这个方法 它是会先调用子类的  可以用super.成员方法调用父类的
    }
}

4.继承中构造方法的访问特点

4.1
.子类中所有的构造方法都会访问父类中无参的构造方法 因为子类会继承父类的数据，可能还会使用父类的数据 所以 子类在初始化之前 一定是要先完成父类数据的初始化2.每一个子类构造方法的第一条语句默认都是super()(这句super()写不写结果都是一样的 一般我们是不写的)
4.2 如果父类的无参构造方法被注释了 那子类中就会报错 你可以在子类构造方法中调用父类带参构造方法 或者 在父类中添加无参构造 就可以了 推荐自己给出无参构造方法

public class Fu {
  public Fu(){
      System.out.println("Fu中无参构造方法被调用");
  }
    public Fu(int a){
        System.out.println("Fu中带参构造方法被调用");
    }
}
public class Zi extends Fu{
    public Zi(){
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int a){
        System.out.println("Zi中带参构造方法被调用");
    }
}
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();  //输出 fu中无参构造方法被调用
                          //     Zi中无参构造方法被调用  子类中构造方法被调用的时候它会先去访问到父类的构造方法
        Zi z2 = new Zi(20);  //fu中无参构造方法被调用
                             // Zi中带参构造方法被调用
    }
}

5.继承的注意事项

java中 类中 只支持单继承，不支持多继承 java类中支持多层继承

6.方法重写

6.1 含义：子`类中出现了和父类中一模一样的方法声明 应用：当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}
/*新手机*/
public class NewPhone extends Phone {
    public void call(String name){
        System.out.println("开启视频功能");
        super.call(name);
        //System.out.println("给"+name+"打电话");
    }
}
public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("林青霞");//给林青霞打电话

        System.out.println("-------------");
        NewPhone np = new NewPhone();
        np.call("林青霞");  //在newphone中没有写call()时  它会调用父类的call()   要是子类有重写 那他就是重写的方法
    }
}

6.2 @Override是一个注解 可以帮助我们检查重写方法的方法声明的正确性
6.3 方法重写的注意事项：1.父类中的private私有方法 子类不可能重写 2.子类重写方法时 它的访问权限一定不能比父类的修饰符低 public>默认>private

7.修饰符

7.1 权限修饰符

（1）private ：同一个包中才能访问
（2）默认(不写修饰符) : 同一个包中的子类无关类
（3）protected : 不同包的子类 同包的子类
（4）public ： 不同包的无关类

7.2 状态修饰符

7.2.1final

final 关键字是最终的意思，可以修饰成员方法，成员变量 类 局部变量
被final修饰的成员方法是最终方法，它是不能被重写的
被final修饰的成员变量变量不能再被赋值了 说明它已经是一个常量了
被final修饰的类就是最终类 所以它是不能有子类了 不能被继承
final修饰局部变量（1）final修饰基本类型变量 不能再赋值 已变成常量（2）被修饰的地址值是不能变的 但是地址值里内容是可以变的

7.2.2 static

1.被static修饰的成员变量 它是会变成斜体的
2.特点：
（1）共享：static修饰的成员 叫做静态成员 也叫类成员(属于这个类的成员) 它有这样的特征：无论这个类它实例化出来多少个对象 都是会共用同一块静态空间 static int price 对于价格而言 它是共用同一块存储空间的
（2 ）生命周期长：对于普通的成员而言，当这个类的对象实例产生的时候 它的相关成员会产生 而当这个对象销毁的时候 这些成员就会进行资源的释放 静态成员不然 它是类第一次加载的时候它就会产生 一直到这个类不再有任何的对象被使用 也就是它彻底被销毁的时候 静态成员它才会进行资源的释放 它是很长寿的
（3）static不能修饰在类名前面 也不能添加在局部变量前， 可以有静态的成员属性，静态的成员方法 静态方法中不能使用this
3.方法调用
（1）在非静态成员方法可有调用非静态成员变量和静态成员变量 可以调用非静态成员方法 静态成员方法 所以在非静态成员方法是可以访问我们所有静态和非静态的成员
（2）静态方法中不能直接访问同一个类中的非静态成员，只能直接调用同一类中的静态成员 总结：静态成员方法只能直接访问静态成员 要是我就是想在静态的方法里面调用非静态的成员，难道没有办法了吗？—只能通过对象实例化后，对象.成员方法 对象.成员属性去访问------------解释：静态方法先于对象存在，当你创建一个对象时，程序为其在堆中分配内存，一般是通过this指针来指向该对象。静态方法不依赖于对象的调用，它是通过‘类名.静态方法名’这样的方式来调用的。而对于非静态方法，在对象创建的时候程序才会为其分配内存，然后通过类的对象去访问非静态方法。因此在对象未存在时非静态方法也不存在，而静态方法自然不能调用一个不存在的方法。

8. 代码块

8.1普通代码块

出现在方法里面的{} 他的执行顺序和一般的语句的执行顺序是一样的 顺序执行 这个普通代码块是可以有很多个 可以在任意的位置

8.2 构造代码块

直接在类中定义的{} 那他和构造方法有没有什么关系呢？ 构造代码块是创建对象时调用，优先于构造方法执行 也可以有多个 顺序执行

8.3 静态代码块

在构造代码块前加static修饰 static{} 类加载时调用，优先于构造代码块执行 也是可以有多个静态代码块 顺序执行

问题：既然static代表的是类共有的相关信息，那么当我在测试类当中 创建了多个实例的时候 静态代码块它会执行几次？构造代码块会执行几次？
答案：静态代码块 无论你实例多少个对象 它都只执行一次 而构造代码块它是会在你每一次实例化的时候都会执行一次
仅希望执行一次的代码可以放在静态代码块中 提高我们的程序的效率