day08.封装+标准JavaBean+继承+代码块

  1.  课前回顾:
  2.   1.可变参数
  3.     a.什么时候使用:参数的类型确定但是个数不确定
  4.     b.格式:数据类型...变量名
  5.     c.本质:数组
  6.     d.注意:参数位置只能有一个可变参数,而且只能放到最后
  7.   2.递归:
  8.     a.概述:方法自己调用自己->直接递归
  9.           方法互相调用->间接递归
  10.     b.注意:
  11.       递归的时候需要求条件,保证递归退出
  12.       不要递归次数过多
  13.   3.对象数组:
  14.     存储的是对象的地址值(地址值就代表一个对象),取出来的还是对象地址值(地址值就代表一个对象)
  15.   4.二分查找
  16.     a.概述:每次查找都干掉一半,从中间索引开始查询
  17.     b.中间索引:(min+max)/2
  18.     c.查询过程:
  19.       key>arr[mid]->min = mid+1
  20.       key<arr[mid]->max = mid-1
  21.   5.命令行参数
  22.     通过命令行给main方法中的String[]赋值->没啥用
  23.   6.封装:
  24.     a.将细节隐藏起来,再将该暴露的暴露出来
  25.     b.比如:
  26.       定义一个方法,方法的具体实现就是细节,将细节放到方法体中
  27.       对外提供方法名,方便别人调用
  29.       将成员变量私有化->private(被private修饰的成员只能此类内部使用,外界不能直接调用)
  30.       针对于私有化的成员变量提供了getxxx/setxxx方法
  31.       getxxx:获取属性值
  32.       setxxx:为属性赋值
  34. 今日重点:
  35.   1.会利用this关键字区分重名的成员变量和局部变量
  36.   2.利用无参构造创建对象
  37.   3.利用有参构造创建对象并为属性赋值
  38.   4.如何快速编写一个标准的javabean
  39.   5.会编写继承,成员的访问
  40.   6.会重写父类中的方法,以及知道重写的意义
  41.   7.会利用super调用父类的成员
  42.   8.会利用this调用本类的成员
  43.   9.知道继承的特点
  44.   10.在继承的前提下,会给父类中的私有属性赋值
  45.   11.会使用静态代码块

第一章.封装

1.封装的介绍以及使用

  1. 1.面向对象三大特征:  [封装]    继承    多态
  2. 2.什么是封装思想:
  3.   a.为什么需要封装？封装的作用和含义？
  4.    我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
  5.   b.隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
  7.     将细节隐藏起来,对外提供一个暴露的接口,供我们使用者使用,我们只需要调用这个接口,接口中的细节(代码)就执行起来了
  9. 3.权限修饰符:private(私有的)
  10.   作用:某个成员一旦被private修饰,别的类是调用不了这个私有成员的
  12. 4.注意:如果一个成员被私有化了,我们外界就彻底使用不了,在封装思想中,我们一般会针对私有的成员对外提供对应的public 的方法 用来间接的去操作私有成员
  14.    getxxx()方法:获取属性值
  15.    setxxx()方法:为属性赋值
  1. public class Person {
  3.     String name;
  4.     /*
  5.       一个成员一旦被private修饰了,外界是不能直接使用的
  6.       只能自己本类中使用
  7.      */
  8.     private int age;
  10.     //针对属性提供对外暴露的方法:get/set方法
  11.     public void setAge(int nianLing){
  12.         if (nianLing<0){
  13.             System.out.println("输入的不合理");
  14.         }else{
  15.             age = nianLing;
  16.         }
  18.     }
  20.     //提供get方法
  21.     public int getAge(){
  22.         return age;
  23.     }
  24. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         person.name = "金莲";
  5.         //person.age = 26;
  6.         person.setAge(26);
  8.         System.out.println(person.name+"..."+person.getAge());
  9.     }
  10. }

day08[封装_标准JavaBean_继承_代码块] - 图1

ps:

如果成员变量没有被private修饰,我们可以提供get/set 也可以不提供get/set

如果成员变量被private修饰了,我们就必须提供get/set方法了

2.this的介绍

  1. 1.注意:在一个方法中局部变量和成员变量重名时,遵循"就近原则",先操作局部的
  2. 2.this
  3.   a.概述:代表的当前对象
  4.         哪个对象调用this所在的方法,this就代表哪个对象
  5.   b.用法:this.成员变量名
  6.   c.作用:
  7.     在一个类中,可以区分重名的成员变量和局部变量
  1. public class Person {
  2.     String name;
  3.     public void speak(String name){
  4.         System.out.println(this);
  5.         System.out.println(this.name+"您好,我是"+name);
  6.     }
  7. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         System.out.println(person);
  5.         person.name = "涛哥";//给成员变量name赋值
  6.         person.speak("柳岩");//给speak的参数赋值
  8.         System.out.println("=================");
  10.         Person person1 = new Person();
  11.         System.out.println(person1);
  12.         person1.name = "张学良";
  13.         person1.speak("张作霖");
  14.     }
  15. }

day08[封装_标准JavaBean_继承_代码块] - 图2

  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     public void setName(String name){
  6.         this.name = name;
  7.     }
  9.     public String getName(){
  10.         return name;
  11.     }
  13.     public void setAge(int age){
  14.         this.age = age;
  15.     }
  17.     public int getAge(){
  18.         return age;
  19.     }
  20. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         person.setName("柳岩");
  5.         person.setAge(36);
  7.         System.out.println(person.getName()+"..."+person.getAge());
  8.     }
  9. }

day08[封装_标准JavaBean_继承_代码块] - 图3

3.构造方法

  1. 1.专门用于创建对象的
  2. 2.没有返回值,没有返回值类型,连void都没有

3.1空参构造

  1. 1.格式:
  2.   public 类名(){
  4.   }
  5. 2.使用:new对象就相当于调用了构造方法
  6. 3.注意:
  7.   每个类都有构造方法,如果没有写,jvm会自动提供一个空参构造
  8. 4.作用:new对象用

3.2有参构造

  1. 1.格式:
  2.   public 类名(){
  3.       为属性赋值的代码
  4.   }
  5. 2.作用:
  6.   a.new对象使用
  7.   b.为属性赋值
  8. 3.注意:
  9.   如果写了有参构造,jvm将不再提供空参构造,所以我们一般将空参和有参构造都手动写出来
  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     public Person(){
  7.     }
  9.     public Person(String name,int age){
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  15.     public void setName(String name){
  16.         this.name = name;
  17.     }
  19.     public String getName(){
  20.         return name;
  21.     }
  23.     public void setAge(int age){
  24.         this.age = age;
  25.     }
  27.     public int getAge(){
  28.         return age;
  29.     }
  30. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         person.setName("柳岩");
  5.         person.setAge(36);
  6.         System.out.println(person.getName()+"..."+person.getAge());
  8.         System.out.println("======================");
  10.         Person person1 = new Person("金莲", 26);
  11.         System.out.println(person1.getName()+"..."+person1.getAge());
  12.     }
  13. }

day08[封装_标准JavaBean_继承_代码块] - 图4

  1. 小结:
  2.  1.private:私有化,本类中能使用,别的类不能使用
  3.  2.被private修饰的成员需要提供对应的get/set方法为私有属性赋值/取值
  4.  3.this:代表当前对象,可以区分重名的成员变量和局部变量
  5.  4.无参构造:不写jvm提供
  6.            new对象的
  7.  5.有参构造:
  8.            如果写了有参构造,jvm不提供无参构造了,所以我们都要写上
  9.            new对象,为属性赋值

第二章.标准JavaBean

JavaBean是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：

（1）类必须是具体的和公共的，

（2）并且具有无参数的构造方法，有参构造

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

  1. 1.开发中
  2.   com.atguigu.service  ->  专门装service类
  3.   com.atguigu.dao  ->专门装直接和数据库打交道的类
  4.   com.atguigu.web-> 专门装和页面打交道的类
  5.   com.atguigu.utils-> 专门装工具类的
  6.   com.atguigu.javabean->专门装实体类

day08[封装_标准JavaBean_继承_代码块] - 图5

  1. public class ClassName{
  2.   //成员变量
  4.   //构造方法
  5.       //无参构造方法【必须】
  6.       //有参构造方法【建议】
  8.   //getXxx()
  9.   //setXxx()
  10.   //其他成员方法
  11. }

编写符合JavaBean 规范的类，以人类为例，标准代码如下：

  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     public Person() {
  6.     }
  8.     public Person(String name, int age) {
  9.         this.name = name;
  10.         this.age = age;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  28. }

如何快速编写一个标准的javabean:alt+insert

1.生成空参构造:alt+insert

day08[封装_标准JavaBean_继承_代码块] - 图6

2.生成有参构造:alt+insert

day08[封装_标准JavaBean_继承_代码块] - 图7

3.生成get/set方法:alt+insert

day08[封装_标准JavaBean_继承_代码块] - 图8

测试类，代码如下：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //利用set方法为属性赋值
  4.         Person person = new Person();
  5.         person.setName("涛哥");
  6.         person.setAge(18);
  7.         System.out.println(person.getName()+"..."+person.getAge());
  9.         System.out.println("========================");
  10.         //利用有参构造为属性赋值
  11.         Person person1 = new Person("柳岩", 36);
  12.         System.out.println(person1.getName()+"..."+person1.getAge());
  13.     }
  14. }

小结:

1.知道private的作用吗? 私有成员 别的类不能直接调用

2.知道get/set方法的作用吗? setxxx 为属性赋值 getxxx获取属性值

3.知道空参构造的作用吗?new对象 不写jvm默认给一个

4.知道有参构造的作用吗? new对象 为属性赋值

5.知道this的作用吗? 区分重名的成员变量和局部变量

6.会快捷键吗? alt+insert

第三章.继承

1.什么是继承

  1. 1.父类怎么出来的:
  2.    定义多个类之后,发现重复的内容太多了
  3. 我们没有必要每个类都要写一遍共性的代码
  5. 所有,我们定义一个类,将共性的代码放到这个类中,此类就是"父类",其他的类就可以继承这个"父类",就可以使用父类中抽取出来的共性的代码
  7. 2.继承:更倾向于是一种代码的设计理念
  9. 3.注意:
  10.    子类可以继承父类中的私有和非私有成员
  11.     但是在子类中不能使用私有成员
  13. 4.继承概念不要从"拥有"层面去理解
  14.    要从"是否能使用"层面去理解

day08[封装_标准JavaBean_继承_代码块] - 图9

2.继承如何使用

  1. 1.关键字:  extends
  2. 2.使用:    子类 extends 父类
  1. public class YuanGong {
  2.    String name;
  3.    int age;
  4. }
  1. public class Teacher extends YuanGong{
  2.    //特有功能
  3.     public void teach(){
  4.         System.out.println("涛哥正在讲课");
  5.     }
  6. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         //创建讲师类对象
  4.         Teacher teacher = new Teacher();
  5.         teacher.name = "涛哥";
  6.         teacher.age = 16;
  7.         System.out.println(teacher.name+"..."+teacher.age);
  8.     }
  9. }

在java中类都是有父类的

1.如果一个类明确表示 extends 父类 那么此类的父类就是extends后面的那个父类

2.如果一个类明确表示extends 父类,那么此类的父类 默认是Object类

3.Object是java中所有类的父类

3.继承中,成员变量和成员方法的访问特点

23.1 成员变量

3.1.1 子类和父类中的成员变量不重名:

  1. 如果new的是父类,只能调用父类自己的成员变量
  2. 如果new的是子类对象,既能调用自己的,还能调用从父类中继承过来的
  1. public class Fu {
  2.     int numFu = 100;
  3. }
  1. public class Zi extends Fu{
  2.     int numZi = 10;
  3. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         //创建父类对象
  4.         Fu fu = new Fu();
  5.         System.out.println(fu.numFu);
  6.         /*
  7.           因为numZi是子类特有的
  8.           父类对象不能调用子类中特有成员
  9.          */
  10.         //System.out.println(fu.numZi);
  12.         //创建子类对象
  13.         Zi zi = new Zi();
  14.         System.out.println(zi.numZi);
  15.         System.out.println(zi.numFu);
  16.     }
  17. }

2.1.2.子类和父类中的成员变量重名

  1. 如果是父类对象,调用父类中的成员变量
  2. 如果是子类对象,调用的是子类中(子类中有,先调用子类的,如果子类没有,找父类中的成员变量)->子债父偿
  1. public class Fu {
  2.    int num = 100;
  3. }
  1. public class Zi extends Fu {
  2.     int num = 10;
  3. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.        //创建父类对象
  4.         Fu fu = new Fu();
  5.         System.out.println(fu.num);//父类中的num  100
  6.         //创建子类对象
  7.         Zi zi = new Zi();
  8.         System.out.println(zi.num);//10
  9.     }
  10. }

在继承的前提下,成员变量有一个通用的访问方式:

看等号左边是谁,就调用谁,如果是子类子类没有,找父类

2.2 成员方法

2.2.1.子类和父类中的成员方法不重名:

  1. public class Fu  {
  2.    public void methodFu(){
  3.        System.out.println("我是父类中的method方法");
  4.    }
  5. }
  1. public class Zi extends Fu {
  2.     public void methodZi(){
  3.         System.out.println("我是子类中的method方法");
  4.     }
  5. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.        //创建父类对象
  4.         Fu fu = new Fu();
  5.         fu.methodFu();
  6.         //fu.methodZi();错误,methodZi是子类中特有的,父类类型调用不了
  7.         //创建子类对象
  8.         Zi zi = new Zi();
  9.         zi.methodZi();
  10.         zi.methodFu();
  11.     }
  12. }

2.2.2.子类和父类中的成员方法重名

  1. public class Fu  {
  2.    public void method(){
  3.        System.out.println("我是父类中的method方法");
  4.    }
  5. }
  1. public class Zi extends Fu {
  2.     public void method(){
  3.         System.out.println("我是子类中的method方法");
  4.     }
  5. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         //创建父类对象
  4.         Fu fu = new Fu();
  5.         fu.method();//父类中的方法
  6.         //创建子类对象
  7.         Zi zi = new Zi();
  8.         zi.method();//子类中的method方法
  9.     }
  10. }

在继承的前提下,成员方法通用的访问特点:

看new的是谁,就先调用谁的成员方法,如果new的是子类,子类没有,找父类

4.方法的重写

  1. 1.前提:必须是在继承的前提下
  2. 2.概述:子类中有一个和父类一样的方法(包括方法名,参数列表)
  3. 3.如何去判定一个方法是否为重写的方法呢?
  4.   在方法上:写 @Override->只要是@Override不报错,证明此方法为重写的方法
  1. public class Fu  {
  2.    public void method(){
  3.        System.out.println("我是父类中的method方法");
  4.    }
  5. }
  1. public class Zi extends Fu {
  2.     @Override
  3.     public void method(){
  4.         System.out.println("我是子类中的method方法");
  5.     }
  6. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Fu fu = new Fu();
  4.         fu.method();
  6.         Zi zi = new Zi();
  7.         zi.method();
  8.     }
  9. }
  1. 重写的方法访问特点:如果new的是子类对象,调用的是子类中重写的方法,子类没有,找父类

4.1.注意事项

  1. 1. 子类方法重写父类方法，必须要保证权限大于等于父类权限。(权限指的是权限修饰符)
  2.    public->protected->默认->private
  3. 2. 子类方法重写父类方法，返回值类型、函数名和参数列表都要一模一样。
  4. 3. 私有方法不能被重写

4.2.使用场景

  1. 1.重写的方法使用场景:用于功能的更新

day08[封装_标准JavaBean_继承_代码块] - 图10

  1. public class HanBing {
  2.     public void Q(){
  3.         System.out.println("加攻速,减速");
  4.     }
  6.     public void W(){
  7.         System.out.println("万箭齐发");
  8.     }
  10.     public void E(){
  11.         System.out.println("鹰击长空");
  12.     }
  14.     public void R(){
  15.         System.out.println("魔法水晶箭");
  16.     }
  17. }
  1. public class NewHanBing extends HanBing{
  2.     public void E(){
  3.         System.out.println("鹰击长空,看视野,带有魔法伤害");
  4.     }
  5. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         NewHanBing newHanBing = new NewHanBing();
  4.         newHanBing.Q();
  5.         newHanBing.W();
  6.         newHanBing.E();
  7.         newHanBing.R();
  8.     }
  9. }
  1. 小结:
  2.   重写:子类中写一个和父类一样的方法
  3.   使用场景:想对父类中某一个方法进行优化升级,就 可以使用重写,不升级的功能直接继承过来

5.继承中构造的特点

  1. 1.注意:
  2.   初始化子类对象是先初始化父类对象
  3. 2.原因:
  4.   构造中默认第一行会有一个super()-> super() 代表的是 父类构造方法
  1. public class Fu {
  2.     public Fu(){
  3.         System.out.println("我是父类中的空参构造");
  4.     }
  5. }
  1. public class Zi extends Fu{
  2.     public Zi(){
  3.         super();
  4.         System.out.println("我是子类中的空参构造");
  5.     }
  6. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Zi zi = new Zi();
  4.     }
  5. }

6.super和this的具体使用

6.1 super的具体使用

  1. 1.概述:super代表的是父类对象
  2. 2.作用:调用父类中的成员(构造,成员变量,成员方法)
  3. 3.使用:
  4.   调用父类的构造方法:  在子类的构造方法中写-> super()->父类的空参构造
  5.                                         super(实参)->父类的有参构造
  7.   调用父类的成员变量:  在子类中写  ->  super.成员变量名
  9.   调用父类的成员方法:  在子类中写  -> super.成员方法名()   或者  super.成员方法名(实参)
  11. 4.注意:
  12.   只要在构造中用super,不管是super()还是super(参数)都要在构造第一行
  1. public class Fu {
  2.     int num  = 100;
  3.     public Fu(){
  4.         System.out.println("我是父类中的空参构造");
  5.     }
  7.     public Fu(int i){
  8.         System.out.println("我是父类中的有参构造");
  9.     }
  11.     public void method(){
  12.         System.out.println("我是父类中的method方法");
  13.     }
  14. }
  1. public class Zi extends Fu{
  2.     int num = 10;
  3.     public Zi(){
  4.        //调用父类中的空参构造,不是继承过来的
  5.         //super();
  6.         //调用父类中的有参构造,不是继承过来的
  7.         super(1);
  8.     }
  10.     public void method(){
  11.         System.out.println(super.num);//父类中的num
  12.         super.method();//父类中的method方法
  13.     }
  14. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Zi zi = new Zi();
  4.         zi.method();
  5.     }
  6. }

6.2 this的具体使用

  1. 1.概述:
  2.   代表的是当前对象
  3.   哪个对象调用的this所在的方法,this就代表哪个对象
  4.   this可以区分重名的成员变量和局部变量
  5. 2.使用:
  6.   调用当前类的构造->  在当前类构造中写  -> this():当前类的空参构造
  7.                                     this(参数):当前类的有参构造
  8.   调用当前类的成员变量  -> 在当前类中写  ->this.成员变量名
  9.   调用当前类的成员方法  -> 在当前类中写  -> this.成员方法名()或者 this.成员方法名(实参)
  1. public class Zi {
  2.     int num = 100;
  3.     public Zi(){
  4.         //调用当前类的有参构造
  5.         //this(1);
  6.         System.out.println("我是当前类的无参构造");
  7.     }
  9.     public Zi(int i){
  10.         //调用当前类中的空参构造
  11.         //this();
  12.         System.out.println("我是当前类的有参构造");
  13.     }
  15.     public void method01(){
  16.         int num = 10;
  17.         System.out.println(num);//局部变量num 就近原则
  18.         System.out.println(this.num);//成员变量num
  19.         this.method02();//调用的是当前类的成员方法
  20.         method02();
  21.     }
  23.     public void method02(){
  24.         System.out.println("我是method02方法");
  25.     }
  26. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Zi zi = new Zi();
  4.         zi.method01();
  5.     }
  6. }

注意:

不能再 用一个构造方法中同时使用super和this

因为super要求在构造第一行,this也要在构造第一行

所以,super和this都出现时,就冲突了

7.继承的特点

  1. 1.继承只支持单继承,不能多继承
  2.   一个儿子只能有一个亲爹
  3. 2.继承支持多层继承
  4. 3.一个父类可以有多个子类

8.问题:如何为父类中private的成员变量赋值(经验值)

  1. //员工类
  2. public class Employee {
  3.     private String name;
  4.     private int age;
  6.     public Employee() {
  7.     }
  9.     public Employee(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  26.     public void setAge(int age) {
  27.         this.age = age;
  28.     }
  29. }
  1. public class Teacher extends Employee{
  2.     public Teacher(){
  4.     }
  5.     public Teacher(String name,int age){
  6.         super(name,age);
  7.     }
  8. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Teacher teacher = new Teacher();
  4.         /*teacher.name = "涛哥";
  5.         teacher.age = 14;
  6.         System.out.println(teacher.name+"..."+teacher.age);*/
  8.         teacher.setName("涛哥");
  9.         teacher.setAge(12);
  10.         System.out.println(teacher.getName()+"..."+teacher.getAge());
  12.         System.out.println("======================");
  14.         //利用有参构造为父类中private属性赋值
  15.         Teacher teacher1 = new Teacher("杨幂", 32);
  16.         System.out.println(teacher1.getName()+"..."+teacher1.getAge());
  17.     }
  18. }

day08[封装_标准JavaBean_继承_代码块] - 图11

第四章.代码块

4.1构造代码块

  1. 1.格式:
  2. {
  3.     代码
  4. }
  6. 2.执行特点:
  7.   构造代码块优先于构造方法执行,每new一次,构造代码块就执行一次
  1. public class Person {
  2.     //构造方法
  3.     public Person(){
  4.         System.out.println("我是构造方法");
  5.     }
  7.     //构造代码块
  8.     {
  9.         System.out.println("我是构造代码块");
  10.     }
  11. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         Person person1 = new Person();
  5.     }
  6. }

4.2静态代码块

  1. 1.格式:
  2.   static{
  3.       代码
  4.   }
  5. 2.执行特点:
  6.   优先于构造方法以及构造代码块执行的,只执行一次
  1. public class Person {
  2.     //构造方法
  3.     public Person(){
  4.         System.out.println("我是构造方法");
  5.     }
  7.     //构造代码块
  8.     {
  9.         System.out.println("我是构造代码块");
  10.     }
  12.     //静态代码块
  13.     static{
  14.         System.out.println("我是静态代码块");
  15.     }
  16. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         Person person1 = new Person();
  5.     }
  6. }

4.3.静态代码块使用场景

  1. 1.如果想让一段代码最先执行,并且只执行一次,就用静态代码块

day08[封装_标准JavaBean_继承_代码块] - 图12