代码块 继承

代码块：

                局部代码块:

   用来限定变量的生命周期,出现在main方法中

  构造代码块:

   类中的成员位置,{代码块}用来给对象的数据进行初始化,每次执行构造方法之前,要执行构造代码块

  静态代码块:

   类中的成员位置,也是用{代码块},在代码的前面,用static代码

  作用:

   静态是和类有关系的,随着类的加载而加载,给类进行初始化，在类中只加载一次!

  面试题:

     静态代码块,构造代码块,构造方法,执行的顺序?
    静态代码块---->构造代码块----->构造方法

                代码：

   /**
 * 看程序:写结果
 * */
class Student {
static {
System.out.println("Student 静态代码块");
}

{
System.out.println("Student 构造代码块");
}

public Student() {
System.out.println("Student 构造方法");
}
}


//测试类
public class StudentDemo {
static {
System.out.println("静态代码块");
}

public static void main(String[] args) {
System.out.println("我是main方法");

Student s1 = new Student();
Student s2 = new Student();
}
}

 继承：

                定义：

   将多个类的共性内容,抽取到一个独立的类中,独立的类和着多个类就产生一种关系:extends:表示继承

格式：

   class Zi extends Fu{
  }

特点：

        1.只支持单继承不支持多继承 
2.可以支持多层继承

代码：

       class GrandFather{
public void method(){
System.out.println("我是爷爷....");
}
}
//父类
class Father extends GrandFather{
public void show(){
System.out.println("我是老子....");
}
}
//子类
//class Zi extends Father,Monther{//多继承
class Zi extends Father{ //单继承


}


//测试类
public class ExtendsDemo {
public static void main(String[] args) {
//创建子类对象
Zi z = new Zi() ;
z.show();//使用老子的方法
z.method();//使用爷爷中的方法
}
}
好处：
   1.提高代码的复用性 
2.提高代码的维护性 
3.是多态的前提，提供了类与类的关系
注意事项：
   1.子类不能继承父类的私有成员（成员变量/成员方法） 
2.子类可以通过关键字super间接地访问父类的构造方法
使用：
   继承是一种属于关系，是is a 的关系。
继承中的成员访问特点：
   A:成员变量
    a：先在子类中的成员方法的局部位置查找，有就输出
                 b：没有就访问子类的成员位置，有就输出
                 c：没有就访问父类的成员位置，有就输出
                 d：没有就会报错
   B:成员方法
    this.成员方法；//访问的是本类的成员方法
                 super.成员方法；//访问的是父类的成员方法
this和super关键字的使用：
                 this:代表的是当前类的对象
  super:代表的是父类的引用    
应用场景;
   成员变量
  this.成员变量: 访问当前类中 的成员变量
  super.成员变量: 访问的是父类中的成员变量
  构造方法
  this(...); 访问的是本类中构造方法
  super(".."); 访问的是父类中的无参构造
  成员方法
  this.成员方法; 访问的是本类的成员方法
  super.成员方法; 访问的就是父类中的成员方法
代码：
   class Fu3{
public int num = 10 ;


}


class Zi3 extends Fu3{
//子类成员位置
public int num = 20 ;

//子类的一个成员方法
public void show(){
int num = 50 ;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}


//测试类
public class ExtendsDemo5 {
public static void main(String[] args) {
Zi3 z = new Zi3() ;
z.show();
}
}

               初始化：

   首先父类进行初始化,然后子类进行初始化;多层访问!

解决父类中没有无参构造的方法：

        1.在父类中给出无参构造方法
  2.使用super关键字去显示的访问父类中的带参构造
  super关键字写法:写在所有语句中的最上面:第一句话!
  3.子类的构造可以使用this关键字去调用其他的构造方法,去间接的访问父类的带参

代码：

class Fu4{

public Fu4(){
System.out.println("这是父类的无参构造方法");
}

public Fu4(String name){
System.out.println("这是父类的有参构造方法");
}
}


class Zi4 extends Fu4{
public Zi4(){
// super();
System.out.println("子类的无参构造方法");
}

public Zi4(String name){
// super() ;
System.out.println("子类的有参构造方法");
}

}


//测试类
public class ExtendsDemo6 {
public static void main(String[] args) {
//创建子类的对象
Zi4 z  = new Zi4() ;
System.out.println("---------------");
Zi4 z2 = new Zi4("输出") ;

}
}