继承

static关键字的特点:
 * a:static随着类的加载而加载
 * b:优先于对象存在,共享的,共用的
 * static:共享的,共用的,
 * 举例:一个班级的学生共用一个班级号
 * 这个特点告诉我们,什么情况下去使用static关键字,很多对象共用一个成员变量/成员方法的时候,可以使用


static修饰
 * 举例:
 * 饮水机(共用的)
 * 水杯(肯定不能共用的)

C:使用对象名可以去访问成员变量,如果这个成员变量被static修饰,那么可以被类名直接调用

 * */class Demo{int num = 10;//非静态的成员变量static int num2 = 20;//静态的成员变量public static void show(){System.out.println("show");}}public class StaticDemo {public static void main(String[] args) {Demo d = new Demo();System.out.println(d.num);// 10System.out.println(d.num2);//  20  使用对象名调用成员变量System.out.println(Demo.num2);// 20 使用类名直接调用成员变量d.show();// 用对象名调用成员方法Demo.show();// 使用类名调用成员方法}}

父类里的静态方法不能被子类继承，覆盖

class Aclass {          public  static void go() {  System.out.println("Aclass");  } }public class Bclass extends Aclass {public  static void go() {    System.out.println("Bclass");   }public static void main(String args[]) {                Aclass a = new Aclass();                Aclass a1 = new Bclass();                a.go();                a1.go();}  }/输出 Aclass  Aclass    要是去掉 static   输出 Aclass  BClass

java中,用{}括起来的代码,代码块!

 *
 * 局部代码块:用来限定变量的生命周期,出现在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();//构造代码块   构造方法}}

继承的特点:
A: 在java中,只支持单继承,不支持多继承,
  别的语言,可以支持多继承的:class Zi extends Father,Monther{..}
        B:虽然java中不支持多继承,但是可以支持多层继承

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();//使用爷爷中的方法}}

子类中成员变量和父类中的成员变量名称一致的情况下:怎么办?
 *
 * a):现在子类中的成员方法的局部位置查找,有没有这个变量,有就输出
 * b):如果在子类成员方法的局部位置找不到,就访问子类的成员位置,有就输出
 * c):如果在子类的成员位置找不到,就去访问父类的成员位置
 * d):如果在父类的成员位置找不到,那么就没有这个变量,报错!
 * */

class Fu2{int num = 20 ;}//子类class Zi2 extends Fu2{//子类的成员位置int num2 = 50 ;int num = 100 ;public void show(){//子类的局部位置int num = 200 ;System.out.println(num);System.out.println(num2);}}//测试public class ExtendsDemo4 {public static void main(String[] args) {Zi2 z = new Zi2() ;z.show() ;}}输出   40  20

  构造之间的关系:
  1)子类中的构造方法(有参/无参)都会默认的访问父类中的无参构造方法
2)子类中的构造方法的第一句话被隐藏:super(); 
  为什么子类的构造方法会默认的访问父类的无参构造?
  表示子类继承父类进行初始化,父类初始化完毕,才能进行子类的初始化!
 
  子类继承父类的访问特点:首先父类进行初始化,然后子类进行初始化;多层访问!

class Fu1{public Fu1(){System.out.println("这是父类的无参构造");}public Fu1(String name){System.out.println("这是父类的有参构造");}}class Zi1 extends Fu1{public Zi1(){super();System.out.println("这是子类的无参构造");}public Zi1(String name ){System.out.println("这是子类的有参构造");}}public class ExtendDemo1 {public static void main(String[] args) {Zi1 z = new Zi1();//这是父类的无参构造  这是子类的无参构造Zi1 z1=new Zi1("gao");//这是父类的无参构造      这是子类的有参构造}}

this和super的区别:
  this:本类的对象
  super:父类的对象