代码块&继承&final关键字

时间:2019-03-26
本文章向大家介绍代码块&继承&final关键字,主要包括代码块&继承&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.修饰类:表示一个最终类,表示不能有子类(不能被其他类继承)

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

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

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

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