代码块&继承&final关键字

代码库：

1.用大括号包起来的一段代码，放在不同的位置，有不同的名称，有不同的作用，有不同的执行时机。

2.分类在：

局部代码块

构造代码块

静态代码块

同步代码块（多线程）

局部代码块：

1.格式：使用大括号抱起来的一段代码。

2.位置：方法中

3.作用：限定变量的生命周期

　　 　 在局部代码块中声明的变量，只能在局部变量的范围中使用，一旦出了局部代码块的大括号，变量就不能继续使用了

　　　　某个变量一旦不能使用了，就会被回收，节省内存空间

4.注意事项：如果实在局部变量代码块中声明了变量，会减少变量的生命周期，出了局部代码块就无法继续使用局部代码块中声明的变量

如果是在局部代码块中修订了局部代码块外声明的变量，局部代码块结束之后，并不会消除局部代码块对这个变量的修改。

 

class Demo01_局部代码块 {


public static void main(String[] args) {


int i = 10;


{


System.out.println(i);


i = 20;


int j = 100;


System.out.println(j);


} 


System.out.println(i);//20，局部代码块只对其中声明的变量有效果，对于变量的使用还是和以前一样


//System.out.println(j);不能访问局部代码块中声明的变量


}


}

构造代码块：

1.格式：使用大括号包起来的一段代码

2.位置：类中方法外

3.作用：用于给成员变量赋初始化值

4.构造方法代码块的执行说明:

 　1.在创建对象的时候执行，由JVM默认调用

     2.在构造方法执行之前执行

    3.任意一个构造方法执行之前，都会执行一次构造代码块的内容

   4.如果每个构造方法都执行的内容，提取到构造代码块中。

代码示例：

import java.util.Date;
import java.text.SimpleDateFormat;
class Demo02_构造代码块 {
    public static void main(String[] args) {
        Person p = new Person();
        p.show();

        Person p2 = new Person("lisi", 24);
        p2.show();

        System.out.println("----------------------");
        Man m = new Man("老王");
        m.show();
    }
}
class Person {
    private String name;
    private int age;

    {
        //name = "zhangsan";
        //age = 23;
        System.out.println("构造代码块");
    }

    public Person() {
        System.out.println("空参构造");
    }

    public Person(String name, int age) {
        System.out.println("有参构造");
        //this.name = name;
        //this.age = age;
    }

    public void show() {
        System.out.println(name + ".." + age);
    }
}

class Man {
    private String name;
    private String gender;
    private String createTime;
    {
        gender = "m";
        //获取系统时间，并转换成相应格式的字符串，并且给成员变量赋值
        long time = System.currentTimeMillis();//获取当前系统时间作为创建时间
        Date d = new Date(time);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        createTime = sdf.format(d);
    }

    public Man() {}

    public Man(String name) {
        this.name = name ;
    }

    public void show() {
        System.out.println(name + "..." + gender + "..." + createTime);
    }
}

静态代码块

1.格式

　　static{

    代码块内容

　　}

2.位置：类中方法外

3.作用：用于给静态的成员变量赋初始化值

用于执行那些只需要执行一次的代码，例如驱动加载等等

4.执行特点：

　　1.随着类的加载而执行

　　2.类只加载一次，所以静态代码块只执行一次。

　　3.执行的时机最早：早于所有的对象相关内容。

执行顺序：静态代码块->初始化代码块（构造方法代码块）->构造方法

代码示例：

class Demo03_静态代码块 {
    
    static {
        System.out.println("测试类的静态代码块执行了");//1
    }

    public static void main(String[] args) {
        System.out.println("主方法执行了");//2
        StaticDemo sd1 = new StaticDemo();
        StaticDemo sd2 = new StaticDemo(666);
    }
}

class StaticDemo {
    static {
        System.out.println("StaticDemo的静态代码块执行了");//3
    }

    {
        System.out.println("staticDemo的构造代码块执行了");//4,6
    }

    public StaticDemo() {
        System.out.println("StaticDemo的空参构造执行了");//5
    }

    public StaticDemo(int i) {
        System.out.println("StaticDemo的有参构造执行了");//7
    }
}

继承：

1.继承的概念：让类与类产生关系，父子类的关系。

2.关键字：extends 扩展，增加，继承

3.父类和子类：

父类：被继承的类，超类（super），基类（base）

子类：用于继承的类，派生类。

代码示例：

class Demo05_有继承的情况 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setColor("black");
        c.setAge(3);
        System.out.println(c.getColor() + "..." + c.getAge());
    }
}

class Animal {
    private String color;
    private int age;

    public void setColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

class Cat extends Animal {

}

class Dog extends Animal {

}

创建对象的顺序：

创建子类对象时，先创建父类的对象，直到创建到Object类为止。

由于父类加载到内存中，因此子类可以使用父类的非Private修饰的属性与方法。

但父类不能使用子类的属性和方法，和访问修饰符无关。

Object类是所有类的父类（除自身以外）

重写：@Override  重写的注解

父类方法不能满足子类的需求，子类中重写父类的方法。

重写与重载的区别：

重载：在一个类中，方法名相同，参数列表不同

重写，至少两个类，方法名相同，参数列表相同

继承的好处与弊端：

1.好处：提高了代码的重用性

　　提高了代码的可维护性

　　是多态的前提

2.弊端：提高了代码的耦合性（松耦合，解耦合）

耦合性：事物与事物之间的依赖关系，互相影响的程度。

3.开发原则：面向对象最终要实现的目的

高内聚（一个对象可以自己完成各种事情）   低耦合（对于其他代码的依赖性非常低）   代码的复用性高

继承的注意事项：

1.私有的成员不能被继承

父类中有一些私有成员，不能在子类中直接使用。

其实在子类对象中，任然包含了父类中定义的私有成员变量

只不过在子类中，不能直接访问父类中定义的私有成员变量。

2.父类中的构造方法不能继承

代码示例：

class Demo06_继承的注意事项 {
    public static void main(String[] args) {
        Student stu = new Student();
    }
}

class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age =age;
    }
}

class Student extends Person {
    public void show() {
        //System.out.println(name + "..." + age);
    }
}

final关键字：

1.单词含义：最终的，最后的，不能改变的。

2.final关键字，可以修饰类，方法，变量。

3.修饰类：表示一个最终类，表示不能有子类（不能被其他类继承）

一旦一个类不能被继承，那么其中所有方法都不能被重写

但是不影响当前类的方法被调用

修饰一个方法：表示这是一个最终方法，该方法不能被重写

修饰变量：表示一个最终变量，只能赋值一次。