08.01_面向对象(代码块的概述和分类)

  • A:代码块概述

    • 在Java中，使用{}括起来的代码被称为代码块。

  • B:代码块分类

    • 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
      局部代码块：只要是和局部有关系的，都是和方法有关系的
      局部变量：在方法声明上或者在方法内部
      构造代码块与类变量谁在前先加载谁 ,所有静态的东西(静态方法和静态变量都是)只加载一次,就是在类文件加载的时候加载,类文件释放的时候释放,加载顺序为,静态,–>–>构造代码块或局部变量–>构造函数
      构造代码块跟成员变量优先顺序是相同的谁在前先执行谁

  • C:常见代码块的应用

    • a:局部代码块

      • 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
    • b:构造代码块 (初始化块)
      • 在类中方法外出现；多个构造方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

    • c:静态代码块

      • 在类中方法外出现，并加上static修饰；用于给类进行初始化，(成员变量给对象初始化,在创建对象之前执行,)在加载类的时候就执行，并且只执行一次。
      • 一般用于加载驱动
        案例：
        class Demo1_Code {
        public static void main(String[] args) {
        {
        int x = 10; //限定变量的周期
        System.out.println(x);
        }

      Student s1 = new Student();
      System.out.println("—————");
      Student s2 = new Student("张三",23);

    }
    static {
    System.out.println("我是在主方法类中的静态代码块");
    }
    }
    class Student {
    private String name;
    private int age;
    public Student(){
    //study();
    System.out.println("空参构造");
    } //空参构造
    public Student(String name,int age) {//有参构造
    //study();
    this.name = name;
    this.age = age;
    System.out.println("有参构造");
    }
    public void setName(String name) {
    this.name = name;
    }
    public String getName() {
    return name;
    }
    public void setAge(int age) {
    this.age = age;
    }
    public int getAge() {
    return age;
    }
    { //构造代码块:每创建一次对象就会执行一次,优先于构造函数执行
    //System.out.println("构造代码块");
    study();
    }
    public void study() {
    System.out.println("学生学习");
    }
    static { //随着类加载而加载,且只执行一次
    System.out.println("我是静态代码块"); //作用:用来给类进行初始化,一般用来加载驱动
    } //静态代码块是优先于主方法执行
    }

08.02_面向对象(代码块的面试题)

  • A:看程序写结果

    • *

class Student {
static {
System.out.println("Student 静态代码块");
}

  1.         {
  2.             System.out.println("Student 构造代码块");
  3.         }
  5.         public Student() {
  6.             System.out.println("Student 构造方法");
  7.         }
  8.     }
  10.     class Demo2_Student {
  11.         static {
  12.             System.out.println("Demo2_Student静态代码块");
  13.         }
  15.         public static void main(String[] args) {
  16.             System.out.println("我是main方法");
  18.             Student s1 = new Student();
  19.             Student s2 = new Student();
  20.         }
  21.     }

运行结果：
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

08.03_面向对象(继承案例演示)

  • A:继承(extends)

    • 让类与类之间产生关系,子父类关系
  • B:继承案例演示：
    • 动物类,猫类,狗类
    • 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
  • C:案例演示
    • 使用继承前
  • D:案例演示
    • 使用继承后
      案例：
      class Demo1_Extends {
      public static void main(String[] args) {
      Cat c = new Cat();
      c.color = "花";
      c.leg = 4;
      c.eat();
      c.sleep();
      System.out.println(c.leg + "…" + c.color);
      }
      }
      class Animal {
      String color; //动物的颜色
      int leg; //动物腿的个数
      public void eat() { //吃饭的功能
      System.out.println("吃饭");
      }
      public void sleep() { //睡觉的功能
      System.out.println("睡觉");
      }
      }
      class Cat extends Animal {

}
class Dog extends Animal {

}
/*
extends是继承的意思
Animal是父类
Cat和Dog都是子类
*/

08.04_面向对象(继承的好处和弊端)

  • A:继承的好处

    • a:提高了代码的复用性（如果再有个猪的类，只需要直接继承Animal就可以用了）
    • b:提高了代码的维护性 如果要给动物加一个属性name，只需要在Aniaml中添加name就行
    • c:让类与类之间产生了关系，是多态的前提
  • B:继承的弊端
    • 类的耦合性增强了。类与类之间的关系太紧密，一边添加属性，另一边就多了一个，有的时候是期望的，但是有的时候是不期望的。
    • 开发的原则：高内聚，低耦合。内聚：是指自己完成事情的能力，自己能完成就不要麻烦别人
    • 耦合：类与类的关系,类之间的依赖关系
    • 内聚：就是自己完成某件事情的能力

08.05_面向对象(Java中类的继承特点)

  • A:Java中类的继承特点

    • a:Java中的类只支持单继承，不支持多继承。接口支持(一个儿子只能有一个爹，多继承是有安全隐患的)

      • 有些语言是支持多继承，格式：extends 类1,类2,…
    • b:Java支持多层继承(继承体系)
  • B:案例演示
    • Java中类的继承特点

      • 如果想用这个体系的所有功能用最底层的类创建对象
      • 如果想看这个体系的共性功能,看最顶层的类
        案例：
        class Demo2_Extends {
        public static void main(String[] args) {
        DemoC d = new DemoC();
        d.show();
        }
        }
        class DemoA {
        public void show() {
        System.out.println("DemoA");
        }
        }
        class DemoB extends DemoA {
        public void method() {
        System.out.println("DemoB");
        }
        }
        class DemoC extends DemoB {
        public void print() {
        System.out.println("DemoC");
        }
        }

08.06_面向对象(继承的注意事项和什么时候使用继承)

  • A:继承的注意事项

    • a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
    • b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
    • c:不要为了部分功能而去继承
    • 项目经理 姓名 工号 工资 奖金
    • 程序员 姓名 工号 工资(可以抽取一个员工类作为父类来继承)
      补充:类中不能直接写执行代码,执行代码必须写在方法中,
      子父类出现重复变量,使用就近原则,但是一般不会这样用,因为继承就是直接拿来用的,没必要子类自己定义

  • B:什么时候使用继承

    • 继承其实体现的是一种关系："is a"。
      Person
      Student
      Teacher
      水果
      苹果
      香蕉
      橘子

    采用假设法。
    如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
    案例：
    class Demo3_Extends {
    public static void main(String[] args) {
    Son s = new Son();
    s.show();
    }
    }
    class Father {
    private String name;
    private void show() {
    System.out.println("Hello World!");
    }
    }
    class Son extends Father {
    }

08.07_面向对象(继承中成员变量的关系)

  • A:案例演示

    • a:不同名的变量
    • b:同名的变量
      class Demo4_Extends {
      public static void main(String[] args) {
      Son s = new Son();
      s.print();
      }
      }
      class Father {
      int num1 = 10;
      int num2 = 30;//先演示的时候,不加此处的num2
      }
      class Son extends Father {
      int num2 = 20;
      public void print(){
      System.out.println(num1);
      System.out.println(num2);
      }
      }

08.08_面向对象(this和super的区别和应用)

  • A:this和super都代表什么

    • this:代表当前对象的引用,谁来调用我,我就代表谁
    • super:代表当前对象父类的引用
  • B:this和super的使用区别
    • a:调用成员变量

      • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
      • super.成员变量 调用父类的成员变量
    • b:调用构造方法
      • this(…) 调用本类的构造方法
      • super(…) 调用父类的构造方法(最全面的说法是通知父类进行初始化)
        补充 : 类的初始化包括(执行构造代码块/初始化成员变量(两者优先顺序相当谁在前先执行谁)->执行构造函数)

构造器,构造函数,构造方法都是指同一个事物,相同的
* c:调用成员方法
* this.成员方法 调用本类的成员方法,也可以调用父类的方法
* super.成员方法 调用父类的成员方法
案例：
class Demo4_Extends {
public static void main(String[] args) {
Son s = new Son();
s.print();
}
}
/*

  • A:案例演示

    • a:不同名的变量
    • b:同名的变量
      子父类出现同名的变量只是在讲课中举例子有,在开发中是不会出现这种情况的
      子类继承父类就是为了使用父类的成员,那么如果定义了同名的成员变量没有意义了
      */
      class Father {
      int num1 = 10;
      int num2 = 30;
      }
      class Son extends Father {
      int num2 = 20;
      public void print() {
      System.out.println(this.num1); //this既可以调用本类的,也可以调用父类的(本类没有的情况下)
      System.out.println(this.num2); //就近原则,子类有就不用父类的了
      System.out.println(super.num2);
      }
      }

08.09_面向对象(继承中构造方法的关系)

  • A:案例演示

    • 子类中所有的构造方法默认都会访问父类中空参数的构造方法

  • B:为什么呢?

    • 因为子类会继承父类中的数据，可能还会使用父类的数据。

    • 所以，子类初始化之前，一定要先完成父类数据的初始化(顺序是成员变量,构造代码块->构造方法)。然后子类进行初始化(顺序是成员变量,构造代码块->构造方法);
      加载子类字节码之前,先加载父类字节码文件,
      static代码块是加载类字节码文件(.class文件)的时候运行,初始化不包括static代码块的运行
      先加载父->子文件,再初始化父->子类

    • 其实：

      • 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
        案例：
        class Demo5_Extends {
        public static void main(String[] args) {
        Son s = new Son();
        }
        }
        class Father extends Object {
        public Father() {
        super();
        System.out.println("Father 的构造方法");
        }
        }
        class Son extends Father {
        public Son() {
        super(); //这是一条语句,如果不写,系统会默认加上,用来访问父类中的空参构造
        System.out.println("Son 的构造方法");
        }
        }

08.10_面向对象(继承中构造方法的注意事项)

  • A:案例演示

    • 父类没有无参构造方法,子类怎么办?
    • super解决:用super(….)显式调用父类的有参构造,如:super(name,age);->super("zs",30);
    • this解决:通过this调用本类的有参构造,然后在本类的有参构造里,又调用了父类的有参构造,相当于间接调用父类的有参构造.

  • B:注意事项

    • super(…)或者this(….)必须出现在构造方法的第一条语句上,只能出现其一
      案例：
      class Demo6_Extends {
      public static void main(String[] args) {
      Son s1 = new Son();
      System.out.println(s1.getName() + "…" + s1.getAge());
      System.out.println("——————–");
      Son s2 = new Son("张三",23);
      System.out.println(s2.getName() + "…" + s2.getAge());
      }
      }
      class Father {
      private String name; //姓名
      private int age; //年龄
      public Father() { //空参构造
      System.out.println("Father 空参构造");
      }
      public Father(String name,int age) { //有参构造
      this.name = name;
      this.age = age;
      System.out.println("Father 有参构造");
      }
      public void setName(String name) { //设置姓名
      this.name = name;
      }
      public String getName() { //获取姓名
      return name;
      }
      public void setAge(int age) { //设置年龄
      this.age = age;
      }
      public int getAge() { //获取年龄
      return age;
      }
      }
      class Son extends Father {
      public Son() { //空参构造
      this("王五",25); //本类中的构造方法
      //super("李四",24); //调用父类中的构造方法

      System.out.println("Son 空参构造");
      }
      public Son(String name,int age) { //有参构造
      super(name,age);
      System.out.println("Son 有参构造");
      }
      }
      class Son extends Father {
      public Son() { //空参构造
      this("王五",25); //本类中的构造方法
      //super("李四",24); //调用父类中的构造方法
      System.out.println("Son 空参构造");
      }

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

08.11_面向对象(继承中的面试题)

  • A:案例演示
  • 面试案例一：
    class Fu{
    public int num = 10;
    public Fu(){
    System.out.println("fu");
    }
    }
    class Zi extends Fu{
    public int num = 20;
    public Zi(){
    //super();
    System.out.println("zi");
    }
    public void show(){
    int num = 30;
    System.out.println(num);
    System.out.println(this.num);
    System.out.println(super.num);
    }
    }
    class Test1_Extends {
    public static void main(String[] args) {
    Zi z = new Zi();
    z.show();
    }
    }

面试题案例二：
class Test2_Extends {
public static void main(String[] args) {
Zi z = new Zi();
}
/*
1,jvm调用了main方法,main进栈,因为子要使用父类的东西，所以父类要先加载,一定是先有父亲才有儿子,所以先加载父类字节码文件
2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
第一个输出,静态代码块Fu,第二个输出静态代码块Zi
3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
第三个输出构造代码块Fu,第四个输出构造方法Fu
4,Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi
*/
}
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}

08.12_面向对象(继承中成员方法关系)

  • A:案例演示

    • a:不同名的方法:直接调用就可以
    • b:同名的方法:称为方法的重写,用子类对象直接调用的是子类已经重写的方法
      * 要想调用父类的方法,可以在子类重写的方法中添加super();
      案例：
      class Demo7_Extends {
      public static void main(String[] args) {
      Son s = new Son();
      s.print();
      s.method();
      }
      }
      class Father {
      public void print() {
      System.out.println("Fu print");
      }
      }
      class Son extends Father {
      public void method() {
      System.out.println("Zi Method");
      }
      public void print() {
      super.print(); //super可以调用父类的成员方法
      System.out.println("Zi print");
      }
      }

08.13_面向对象(方法重写概述及其应用)

  • A:什么是方法重写

    • 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类(返回值的类型的子父类),这个我们学完面向对象讲)
  • B:方法重写的应用：
    • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
  • C:案例演示
    • a:定义一个手机类。
      案例：
      /*
      ios7系统 siri speak English
      ios8系统 siri 说中文
      */
      class Demo7_Phone {
      public static void main(String[] args) {
      Ios8 i = new Ios8();
      i.siri();
      i.call();
      }
      }
      class Ios7 {
      public void call() {
      System.out.println("打电话");
      }
      public void siri() {
      System.out.println("speak English");
      }
      }
      class Ios8 extends Ios7 {
      public void siri() {
      System.out.println("说中文");
      super.siri();
      }
      }

08.14_面向对象(方法重写的注意事项)

  • A:方法重写注意事项

    • a:父类中私有方法不能被重写

      • 因为父类私有方法子类根本就无法继承,既然子类无法继承,就谈不上重写了
    • b:子类重写父类方法时，访问权限不能更低
      • 最好就一致,(补充,访问权限大小排序 public>不写权限>private);

    • c:父类静态方法，子类也必须通过静态方法进行重写

      • 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)

    • 子类重写父类方法的时候，最好声明一模一样。

  • B:案例演示
    • 方法重写注意事项
      案例：
      class Demo8_双桨 {
      public static void main(String[] args) {
      DayOne d = new DayOne();
      d.泡妞();
      d.print();
      }
      }
      class 双桨 {
      public void sing() {
      System.out.println("唱红歌");
      }
      public void 泡妞() {
      System.out.println("唱红歌搞定林夕合鸟女士");
      }
      public static void print() {
      System.out.println("Fu print");
      }
      }
      class DayOne extends 双桨 {
      public void 泡妞() {
      System.out.println("霸王硬上弓");
      }
      public static void print() { //静态只能覆盖静态,其实不算重写,多态时候详细讲解
      System.out.println("Zi print");
      }
      }

08.15_面向对象(方法重写的面试题)

  • A:方法重写的面试题

    • Override和Overload的区别?Overload能改变返回值类型吗?
    • overload可以改变返回值类型,只看参数列表

    • 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的

    • 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。

    • 子类对象调用方法的时候：

      • 先找子类本身，再找父类。

08.16_面向对象(使用继承前的学生和老师案例)

  • A:案例演示

    • 使用继承前的学生和老师案例
    • 属性:姓名,年龄
    • 行为:吃饭
    • 老师有特有的方法:讲课
    • 学生有特有的方法:学习
      案例：
      class Test3_Person {
      public static void main(String[] args) {
      System.out.println("Hello World!");
      }
      }
      class Student {
      private String name; //姓名
      private int age; //年龄
      public Student() {} //空参构造
      public Student(String name,int age) { //有参构造
      this.name = name;
      this.age = age;
      }
      public void setName(String name) { //设置姓名
      this.name = name;
      }
      public String getName() { //获取姓名
      return name;
      }
      public void setAge(int age) { //设置年龄
      this.age = age;
      }
      public int getAge() { //获取年龄
      return age;
      }
      public void eat() { //吃饭
      System.out.println("学生吃饭");
      }
      public void study() { //学习
      System.out.println("学生学习");
      }
      }
      class Teacher {
      private String name; //姓名
      private int age; //年龄
      public Teacher() {} //空参构造
      public Teacher(String name,int age) { //有参构造
      this.name = name;
      this.age = age;
      }
      public void setName(String name) { //设置姓名
      this.name = name;
      }
      public String getName() { //获取姓名
      return name;
      }
      public void setAge(int age) { //设置年龄
      this.age = age;
      }
      public int getAge() { //获取年龄
      return age;
      }
      public void eat() { //吃饭
      System.out.println("老师吃饭");
      }
      public void teach() { //学习
      System.out.println("老师讲课");
      }
      }

08.17_面向对象(使用继承后的学生和老师案例)

  • A:案例演示

    • 使用继承后的学生和老师案例
      案例：
      class Test4_Person {
      public static void main(String[] args) {
      Student s1 = new Student();
      s1.setName("张三");
      s1.setAge(23);
      System.out.println(s1.getName() + "…" + s1.getAge());
      s1.eat();
      s1.study();
      System.out.println("——————");
      Student s2 = new Student("李四",24);
      System.out.println(s2.getName() + "…" + s2.getAge());
      s2.eat();
      s2.study();
      }
      }
      /*
  • 使用继承后的学生和老师案例
    */
    class Person {
    private String name; //姓名
    private int age; //年龄
    public Person() {} //空参构造
    public Person(String name,int age) { //有参构造
    this.name = name;
    this.age = age;
    }
    public void setName(String name) { //设置姓名
    this.name = name;
    }
    public String getName() { //获取姓名
    return name;
    }
    public void setAge(int age) { //设置年龄
    this.age = age;
    }
    public int getAge() { //获取年龄
    return age;
    }
    public void eat() { //吃饭
    System.out.println(name + "吃饭");
    }
    }
    class Student extends Person {
    public Student() {} //空参构造
    public Student(String name,int age) {
    super(name,age); //这里不能直接用this.name=name因为父类中name为私有,而子类中没有name这个变量
    }
    public void study() {
    System.out.println(this.getName() + "学习");
    }
    }
    class Teacher extends Person {
    public Teacher() {} //空参构造
    public Teacher(String name,int age) {
    super(name,age);
    }
    public void teach() {
    System.out.println(this.getName() + "讲课");//在父类中name是私有的,这里不能够直接访问,私有的变量和方法都只能在本类中调用,这里this可以不加,也可以加super
    }
    }

08.18_面向对象(猫狗案例分析,实现及测试)

  • A:猫狗案例分析
  • B:案例演示
    • 猫狗案例继承版
    • 属性:毛的颜色,腿的个数
    • 行为:吃饭
    • 猫特有行为:抓老鼠catchMouse
    • 狗特有行为:看家lookHome
      案例：
      class Test5_Animal {
      public static void main(String[] args) {
      Cat c1 = new Cat("花",4);
      System.out.println(c1.getColor() + "…" + c1.getLeg());
      c1.eat();
      c1.catchMouse();
      Dog d1 = new Dog("黑",2);
      System.out.println(d1.getColor() + "…" + d1.getLeg());
      d1.eat();
      d1.lookHome();
      }
      }
      class Animal {
      private String color; //毛的颜色
      private int leg; //腿的个数
      public Animal(){}
      public Animal(String color,int leg) {
      this.color = color;
      this.leg = leg;
      }
      public void setColor(String color) { //设置颜色
      this.color = color;
      }
      public String getColor() { //获取颜色
      return color;
      }
      public void setLeg(int leg) { //设置腿的个数
      this.leg = leg;
      }
      public int getLeg() { //获取腿的个数
      return leg;
      }
      public void eat() { //吃饭
      System.out.println("吃饭");
      }
      }
      class Cat extends Animal {
      public Cat() {} //空参构造
      public Cat(String color,int leg) { //有参构造
      super(color,leg);
      }
      public void eat() { //吃鱼
      System.out.println("猫吃鱼");
      }
      public void catchMouse() { //抓老鼠
      System.out.println("抓老鼠");
      }
      }
      class Dog extends Animal {
      public Dog() {} //空参构造
      public Dog(String color,int leg) { //有参构造
      super(color,leg);
      }
      public void eat() { //吃肉
      System.out.println("狗吃肉");
      }
      public void lookHome() { //看家
      System.out.println("看家");
      }
      }

08.19_面向对象(final关键字修饰类,方法以及变量的特点)

  • A:final概述
  • B:final修饰特点
    • 修饰类，类不能被继承
    • 修饰变量，变量就变成了常量，只能被赋值一次
    • 修饰方法，方法不能被重写(重写了就报错)(有时所有方法都很重要，都不需要被重写，需要将类定义成final的)
  • C:案例演示
    • final修饰特点
      案例：
      class Demo1_Final {
      public static void main(String[] args) {
      Son s = new Son();
      s.print();
      }
      }
      /final class Father {
      public void print() {
      System.out.println("访问底层数据资源");
      }
      }      /
      class Son /extends Father/ {
      final int NUM = 10; //常量命名规范,如果是一个单词,所有字母大写,如果是多个单词,每个单词都大写,中间用下划线隔开
      public static final double PI = 3.14; //final修饰变量叫做常量,一般会与public static共用
      public void print() {
      //NUM = 20;
      System.out.println(NUM);
      }
      }

08.20_面向对象(final关键字修饰局部变量)

  • A:案例演示

    • 方法内部或者方法声明上都演示一下(了解)

    • 基本类型，是值不能被改变

    • 引用类型，是地址值不能被改变,对象中的属性可以改变
      案例：
      class Demo2_Final {
      public static void main(String[] args) {
      final int num = 10;
      //num = 20;
      System.out.println(num);
      final Person p = new Person("张三",23);
      //p = new Person("李四",24);//不能改变p代表的是对象的地址,但是这个地址下对象的属性可以改变
      p.setName("李四");
      p.setAge(24);
      System.out.println(p.getName() + "…" + p.getAge());
      method(10);
      method(20);
      }
      public static void method(final int x) {
      System.out.println(x);
      }
      }
      class Person {
      private String name; //姓名
      private int age; //年龄
      public Person(){} //空参构造
      public Person(String name,int age) {
      this.name = name;
      this.age = age;
      }
      public void setName(String name) { //设置姓名
      this.name = name;
      }
      public String getName() { //获取姓名
      return name;
      }
      public void setAge(int age) { //设置年龄
      this.age = age;
      }
      public int getAge() { //获取年龄
      return age;
      }
      }

08.21_面向对象(final修饰成员变量的初始化时机)

  • A:final修饰成员变量的初始化时机

    • 显示初始化(明显赋值就是显示初始化)不可以用final int A;A=10;这样初始化,其实如果写A=10,就相当于在类中,函数外直接写代码,这肯定是不可以运行的;
    • 在对象构造完毕前即可(即构造函数中赋值也可以,如果有两个构造函数必须有参构造和无参构造函数中都赋值,保证无论怎么调用构造函数,这个引用常量都会有值,)
      只有这两种方式;
      案例：
      class Demo3_Final {
      public static void main(String[] args) {
      Demo d = new Demo();
      d.print();
      }
      }
      class Demo {
      //final int num = 10; //表示显式初始化
      final int num; //成员变量的默认初始化值是无效值
      //因为final修饰的变量只能被赋值一次,所以会特别珍惜这次赋值,所以系统的默认初始化值是无效的

    public Demo() {
    num = 10;
    }
    public void print() {
    System.out.println(num);
    }
    }

08 java代码块的概述和分类的更多相关文章

  1. Java代码块详解

    Java中代码块指的是用 {} 包围的代码集合,分为4种:普通代码块,静态代码块,同步代码块,构造代码块 普通代码块: 定义:在方法.循环.判断等语句中出现的代码块 修饰:只能用标签修饰 位置:普通代 ...

  2. java代码块的理解

    最近在复习java基础,在看到java代码块的时候,忽然发现自己貌似对于java代码块一无所知,于是赶紧对着一些资料实战演练了一把. 对于java代码块,不难根据名称看出其实就是一些java语句的集合 ...

  3. java代码块执行顺序

    父类 public class Father { public Father() { System.out.println("父类构造PUBLIC father"); } stat ...

  4. 夯实Java基础系列7：一文读懂Java 代码块和执行顺序

    目录 Java中的构造方法 构造方法简介 构造方法实例 例 1 例 2 Java中的几种构造方法详解 普通构造方法 默认构造方法 重载构造方法 java子类构造方法调用父类构造方法 Java中的代码块 ...

  5. 夯实Java基础系列7：Java 代码块和执行顺序

    本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下 ...

  6. Java 代码块详解

    注:本文出自博主 Chloneda:个人博客 | 博客园 | Github | Gitee | 知乎 注:本文原链接:https://www.cnblogs.com/chloneda/p/java-c ...

  7. java代码块 静态、非静态

    Java虚拟机的内存分区:Java栈.堆.方法区.本地方法栈.PC寄存器.还有一个常量池的概念,虚拟机会为每种类型分配一个常量池,而不是实例. 例如有一个类有很多子类,那么在父类定义的final变量, ...

  8. Java——代码块

    前言 在程序编写之中可以直接使用{...}定义的一段语句就是代码块.根据代码块的位置以及关键字的不同可以分为4种:普通代码块.构造块.静态块以及同步代码块(多线程相关).下面将先介绍前3种以及Java ...

  9. 08-02 Java 代码块，代码块执行的先后顺序问题

    代码块 /* 代码块:在Java中,使用{}括起来的代码被称为代码块. 根据其位置和声明的不同,可以分为 局部代码块:局部位置,用于限定变量的生命周期. 构造代码块:在类中的成员位置,用{}括起来的代 ...

随机推荐

  1. 20150709---Web中GridView控件根据绑定的数据显示不同的图片

    示例图: 根据数据判断,显示各种不同的图片 该列的前端代码: <asp:TemplateField HeaderText="审图"> <ItemTemplate& ...

  2. 如何录制视频生成GIF动态图?

    前言 在分享文章时有些知识不好讲清,就打算用gif图来展示,可是在网上找了几个录视频的工具都要会员才可以生成gif动态图,很是郁闷,不过苦苦寻找后,发现LICEcap很好用,可以很方便的生成gif动态 ...

  3. 开启关闭mysql服务

    1.Windows下 启动服务 mysqld --console 或 net start mysql 关闭服务 mysqladmin -uroot shudown 或 net stop mysql   ...

  4. k8s-启动、退出动作

    vim post.yaml apiVersion: v1 kind: Pod metadata: name: lifecycle-demo spec: containers: - name: life ...

  5. C++学习书籍推荐

    列出几本侯捷老师推荐的书1. C++程序员必备的书a) <C++ Programming Language> Bjarne Stroustrupb) <C++ Primer> ...

  6. MongoDB Windows之ZIP安装

    下载.下载地址同MSI下载地址:https://www.mongodb.com/download-center/community .Package选择Zip. 下载完成后解压到对应文件夹,该文件夹就 ...

  7. python基础篇(文件操作)

    Python基础篇(文件操作) 一.初始文件操作 使用python来读写文件是非常简单的操作. 我们使用open()函数来打开一个文件, 获取到文件句柄. 然后通过文件句柄就可以进行各种各样的操作了. ...

  8. Docker入门 .Net Core 使用Docker全程记录

    https://www.cnblogs.com/flame7/p/9210986.html Docker入门 第一课 --.Net Core 使用Docker全程记录   微服务架构无疑是当前最火热的 ...

  9. IDEA compile successfully many errors still occur

    Compile and install successfully with maven in IDEA, but error prompt still popup. Your local enviro ...

  10. scroll兼容性

    document.html=>document.documentElement function scroll() { if(window.pageYOffset != null) // ie9 ...