java中的代码块和java的继承关系，

java中的代码块和java的继承关系，

代码块
代码块其实就是大括号中的代码.
代码块可以分为四类
1.局部代码块
局部代码块的位置就是在方法中,主要是用来限定局部变量的生命周期的
2.构造代码块
构造代码块的位置是在类中方法外,构造代码块在对象初始化的时候,是优先于构造方法加载的,即先加载构造代码块再加载构造方法的
构造方法的运用场景就是如果一个类的对象都有相同的方法,则可以使用构造代码块
3.静态代码块
静态代码块的位置是在类中方法外,并且静态代码块是随着类的加载而加载的,指挥加载一次的,一般运用于加载驱动
4.同步代码块(多线程中使用)
下面我们来整体看一下,几个代码块的加载顺序

public class Demo 
{
public static void main(String[] args) 
{
    Test test = new Test();
    test.sayHi();
}
}
class Test
{
    String name;
    {
        System.out.println("我是构造代码块");
    }
    public Test()
    {
        System.out.println("我是构造方法");
    }
    public void sayHi()
    {
        {
            System.out.println("我是局部代码块");
        }
    }
    static
    {
        System.out.println("我是静态代码块");
    }
}

输出结果是

我是静态代码块
我是构造代码块
我是构造方法
我是局部代码块

继承
继承就是把相同的代码抽取出来写一个父类,不同的部分写入子类,子类继承父类,父类中的非私有的成员变量和方法,子类中都有.
但是java中的继承只允许单继承,不允许多继承,但是可以多层继承,多层继承的属性和方法也会多层传递的.继承用extends来表示

class A
{
    String name;
    int age;
    public void sayHi()
    {
    System.out.println(name);
    }
}
class B extends A
{
}
class C extends B
{   
}

public static void main(String[] args)
{
C c = new C();
c.name = “张三”;
c.sayHi();
}
输出的结果是张三,这就是多层继承,A中的属性和方法也会多层继承,传递到C中

子类并不能继承父类中的构造方法

class Father
{
    String name;
    int age;
    //无参数的构造方法
    public Father()
    {
        System.out.println("我是父类的无参数的构造方法");
    }
    //有参数的构造方法
    public  Father(String name,int age)
    {
        this.name  = name;
        this.age = age;
        System.out.println("我是父类的有参数的构造函数");
    }
}
class Son extends Father
{
    //有参数的构造方法
    public Son(String name, int age)
    {
        this.name = name;
        this.age = age;
        System.out.println("我是父类的有参数的构造方法");
    }
    //无参数的构造方法
    public Son()
    {
        System.out.println("我是子类的无参数的构造方法");
    }
    public void sayHi() 
    {
        System.out.println("我是父类方法");
    }
}
public static void main(String[] args) {
    Son son1 = new Son();
    son1.sayHi();
    Son son2 = new Son("张三",18);
    son2.sayHi();   
}

输出的结果是
我是父类的无参数的构造方法
我是子类的无参数的构造方法
我是父类方法
我是父类的无参数的构造方法
我是父类的有参数的构造方法
我是父类方法
由结果可以看出不论子类的构造方法是否有参数,子类每一次调用构造方法的时候都会调用一次父类的无参数的构造方法
即当变量初始化的时候,系统会自动调用一次父类的构造方法,然后再调用子类的构造方法.
但是当父类中既有有参数的构造方法,也有无参数的构造方法的时候,我们可以用super()自己来设置调用的是哪一个父类的构造方法

class Son extends Father
{
    //有参数的构造方法
    public Son(String name, int age)
    {
       super(name,age)//调用父类中有参数的构造方法
        this.name = name;
        this.age = age;
        System.out.println("我是父类的有参数的构造方法");
    }
    //无参数的构造方法
    public Son()
    {
        super();//调用父类中无参数的构造方法
        System.out.println("我是子类的无参数的构造方法");
    }
    public void sayHi() 
    {
        System.out.println("我是父类方法");
    }
}

要注意的是当子类的构造方法中没有用super()来调用父类中的构造方法时,系统会自动调用无参数的构造方法,当我们用super()书写后,系统则会根据我们规定的来调用了,
所以子类既可以调用父类的无参数构造方法,也可以调用有参数的构造方法.
下面我们来介绍一下super和this的区别
super指的是父类的对象,this指的是本类的对象
super.属性调用的是父类中的属性,this.属性调用的是本类中的属性,但是如果本类中没有就从父类中找.
super()调用的是父类的构造方法,this()调用的是本类的构造方法.
java中方法的重写
如果一个子类中的方法和父类中的方法重名,且功能和参数都相同的话,我们就叫做方法的重写.
方法的重写是当子类的方法和父类的方法完全相同时,而方法的重载则需要方法的功能相同但是参数不同
方法的重写的运用场景大多数是功能的升级时会用到,在子类中用super.方法来调用父类原来的方法并在后面加上升级的方法

class Animal
{
    String name;
    public void sayHi() 
    {
        System.out.println("HelloWorld");
    }
}
class Cat extends Animal
{
    @Override,方法的重写
    public void sayHi() {
        // 调用父类的方法
        super.sayHi();
        //增加新的功能
        System.out.println(this.name);
    }
}

父类中的私有属性是不能被继承的
举个例子

class Person
{
    private String name;
    private int age;
    //有参数的构造函数
    public Person(String name, int age)
    {
        this.age = age;
        this.name = name;
    }
    //set/get方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName() 
    {
        return this.name;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public int getAge() 
    {
        return this.age;
    }
}
class Teacher extends Person
{
//有参数的构造方法
    public Teacher(String name, int age)
    {
        super(name,age);//调用父类的构造方法来对父类对象进行赋值
    }
    public void sayHi() 
    {
        System.out.println(this.getName());
    }
}

父类中的参数被private私有化了,子类中无法继承了,但是父类中的set/get方法,子类中则继承了,则在子类的构造方法中调用父类的构造方法,对父类对象进行赋值操作,然后利用继承的set/get方法来获取这些值
final关键字
final关键字可以修饰变量,方法,和类
当修饰的是变量的时候,则表示这个变量的值以后都不能被修改了
当修饰的是方法的时候,则表示这个方法不能被重写
当修饰的是类的时候,则表示这个类不能被继承