• 认识Java中的类和对象（下）

    作者：~小明学编程

    文章专栏：JavaSE基础

    格言：目之所及皆为回忆，心之所想皆为过往
    在这里插入图片描述

    目录

    对象的构造及初始化

    初始化对象

    构造方法

    概念

    特性

    this引用

    什么是this引用

    this调用其它方法的使用

    this在构造函数中的使用

    代码块

    代码块概念以及分类

    普通代码块

    构造代码块

    静态代码块

    赋值优先问题

    注意事项

    匿名对象

    对象的构造及初始化

    初始化对象

    前面我们通过学习知道了Java李里面的变量必须给它赋上一个初始值才行，否则的话就会报错。

    如果是对象的话

    1. class Student {
    2.     public int age;
    3.     public String name;
    4.     public void test() {
    5.         System.out.println("姓名:"+name+" 年龄:"+age);
    6.     }
    7.  
    8.     @Override
    9.     public String toString() {
    10.         return "Student{" +
    11.                 "age=" + age +
    12.                 ", name='" + name + '\'' +
    13.                 '}';
    14.     }
    15. }
    16. public class Dome {
    17.     public static void main(String[] args) {
    18.         Student student = new Student();
    19.         student.test();
    20.         student.age = 18;
    21.         student.name = "张三";
    22.         student.test();
    23.     }
    24. }

    这里我们可以看到我们必须通过引用对象才能给其成员赋值，然后才能调用方法实现我们的需求，这样无疑会很麻烦，我们可以通过我们的构造方法解决上述的问题。

    构造方法

    概念

    构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

    1. class Student {
    2.     public int age;
    3.     public String name;
    4.     public Student (int age,String name){
    5.         this.age = age;
    6.         this.name = name;
    7.         System.out.println("Student方法已被调用");
    8.     }
    9.     public void test() {
    10.         System.out.println("姓名:"+name+" 年龄:"+age);
    11.     }
    12.  
    13.     @Override
    14.     public String toString() {
    15.         return "Student{" +
    16.                 "age=" + age +
    17.                 ", name='" + name + '\'' +
    18.                 '}';
    19.     }
    20. }
    21. public class Dome {
    22.     public static void main(String[] args) {
    23.         Student student = new Student(18,"张三");
    24.         student.test();
    25. //        student.age = 18;
    26. //        student.name = "张三";
    27. //        student.test();
    28.     }
    29. }

     我们可以看到我们在new Student的时候就调用了我们的构造方法，那么之前我们没有写构造方法的时候又是怎么调用构造方法的呢？

    这里是因为当我们没有写构造方法的时候会自动生成一个没有参数的构造方法当我们写了构造方法的时候就会调用我们当前的构造方法。

    注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间
     

    特性

    1. 名字必须与类名相同


    2. 没有返回值类型，设置为void也不行


    3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)


    4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

    5.构造方法可以有参数也可以没有。
     

    1. class Student {
    2.     public int age;
    3.     public String name;
    4.     public Student (int age,String name){
    5.         this.age = age;
    6.         this.name = name;
    7.         System.out.println("Student方法已被调用");
    8.     }
    9.     public Student (int age){
    10.         this.age = age;
    11.         System.out.println("Student方法已被调用");
    12.     }
    13.     public void test() {
    14.         System.out.println("姓名:"+name+" 年龄:"+age);
    15.     }
    16.  
    17.     @Override
    18.     public String toString() {
    19.         return "Student{" +
    20.                 "age=" + age +
    21.                 ", name='" + name + '\'' +
    22.                 '}';
    23.     }
    24. }
    25. public class Dome {
    26.     public static void main(String[] args) {
    27.         Student student = new Student(18,"张三");
    28.         student.test();
    29.         Student student1 = new Student(20);
    30.         student1.test();
    31. //        student.age = 18;
    32. //        student.name = "张三";
    33. //        student.test();
    34.     }
    35. }

     这就是构造方法的重载。

    this引用

    什么是this引用

    this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成
     

    1. public class Date {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5.     public void setDay(int year, int month, int day){
    6.         this.year = year;
    7.         this.month = month;
    8.         this.day = day;
    9.     }
    10. public void printDate(){
    11.     System.out.println(this.year + "/" + this.month + "/" + this.day);
    12.         }
    13. }

    这种用法我们前面已经说过了，this指向当前对象的变量，这样可以排除局部变量对我们方法的影响。

    this调用其它方法的使用

    1.    public void fun1() {
    2.         System.out.println("hello");
    3.     }
    4.     public void fun2() {
    5.         this.fun1();
    6.         System.out.println("hi");
    7.     }

    我们可以通过关键字this来调用当前对象中的其它方法，注意我们不能在静态方法中通过this来调用其它的方法，但是我们可以在普通方法中通过this来调用静态的方法。

    this在构造函数中的使用

    1. class Student {
    2.     public int age;
    3.     public String name;
    4.     public Student() {
    5.         this("张三");
    6.         System.out.println("Student无参数方法");
    7.     }
    8.     public Student (int age,String name){
    9.         this.age = age;
    10.         this.name = name;
    11.         System.out.println("Student2方法已被调用");
    12.     }
    13.     public Student (String name){
    14.         this.name = name;
    15.         System.out.println("Student1方法已被调用");
    16.     }
    17.     public void test() {
    18.         System.out.println("姓名:"+name+" 年龄:"+age);
    19.     }
    20.     public void fun1() {
    21.         System.out.println("hello");
    22.     }
    23.     public void fun2() {
    24.         this.fun1();
    25.         System.out.println("hi");
    26.         this.fun3();
    27.     }
    28.     public static void fun3() {
    29.  
    30.         System.out.println("ok");
    31.     }
    32.     @Override
    33.     public String toString() {
    34.         return "Student{" +
    35.                 "age=" + age +
    36.                 ", name='" + name + '\'' +
    37.                 '}';
    38.     }
    39. }
    40. public class Dome {
    41.     public static void main(String[] args) {
    42.         Student student = new Student();
    43. //        student.fun2();
    44.     }
    45. }

    这里我们可以看到我们在this里面加了参数就能够调用其它的构造方法了。但是这里我们要注意的一点是：在构造方法中使用this(),this()必须放在构造方法中的第一行，同时也就是说构造方法中我们只能够使用一个this语句，并且this()这种用法也只能在构造方法中使用。

    代码块

    代码块概念以及分类

    使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
    1.普通代码块
    2.构造块
    3.静态块
    4.同步代码块

    普通代码块

    1.         public static void main(String[] args) {
    2.             { //直接使用{}定义，普通方法块
    3.                 int x = 10 ;
    4.                 System.out.println("x1 = " +x);
    5.             }
    6.             int x = 100 ;
    7.             System.out.println("x2 = " +x);
    8.         }

    普通代码块就是定义在我们方法中的代码块。


    构造代码块

    构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。
     

    1. public class Student{
    2.     //实例成员变量
    3.     private String name;
    4.     private String gender;
    5.     private int age;
    6.     private double score;
    7.     public Student() {
    8.         System.out.println("I am Student init()!");
    9.     } //实例代码块
    10.     {
    11.         this.name = "bit";
    12.         this.age = 12;
    13.         this.sex = "man";
    14.         System.out.println("I am instance init()!");
    15.     }
    16.     public void show(){
    17.         System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    18.     }
    19. }
    20. public class Main {
    21.     public static void main(String[] args) {
    22.         Student stu = new Student();
    23.         stu.show();
    24.     }
    25. }

    静态代码块

    使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量

    1. class Student {
    2.     public int age;
    3.     public static int score;
    4.     public String name;
    5.     {
    6.         System.out.println("aaa");
    7.     }
    8.     static {
    9.         score = 10;
    10.         System.out.println("ccc");
    11.     }
    12.  
    13.     public Student() {
    14.         this("张三");
    15.         System.out.println("Student无参数方法");
    16.     }
    17.     public Student (int age,String name){
    18.         this.age = age;
    19.         this.name = name;
    20.         System.out.println("Student2方法已被调用");
    21.     }
    22.     public Student (String name){
    23.         this.name = name;
    24.         System.out.println("Student1方法已被调用");
    25.     }
    26.     public void test() {
    27.         System.out.println("姓名:"+name+" 年龄:"+age);
    28.     }
    29.     public void fun1() {
    30.         System.out.println("hello");
    31.     }
    32.     public void fun2() {
    33.         this.fun1();
    34.         System.out.println("hi");
    35.         this.fun3();
    36.     }
    37.     public static void fun3() {
    38.  
    39.         System.out.println("ok");
    40.     }
    41.     @Override
    42.     public String toString() {
    43.         return "Student{" +
    44.                 "age=" + age +
    45.                 ", name='" + name + '\'' +
    46.                 '}';
    47.     }
    48. }
    49. public class Dome {
    50.     public static void main(String[] args) {
    51.         Student student = new Student();
    52.         System.out.println("---------------------------");
    53.         Student student1 = new Student();
    54.     }
    55. }

     

     我们可以看到即使我们的静态代码块放在实例代码块的前面但是依然是先执行我们的静态代码块的，并且静态代码块只执行一次。

    赋值优先问题

    1. class Student {
    2.     public int age;
    3.     public String name;
    4.     {
    5.         System.out.println("aaa");
    6.     }
    7.     static {
    8.         score = 10;
    9.         System.out.println("ccc");
    10.     }
    11.     public static int score=1;
    12. }
    13. public class Dome {
    14.     public static void main(String[] args) {
    15.         System.out.println(Student.score);
    16.  
    17.     }
    18. }

     我们可以看到我们的    public static int score=1;放在在后面此时score的值就是1了，但是放在后面我们不给它初始话的话那么score的值就还是10.

    注意事项

    注意事项
    静态代码块不管生成多少个对象，其只会执行一次


    静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的


    如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)


    实例代码块只有在创建对象时才会执行
     

    匿名对象

    1. class Person {
    2.     private int age;
    3.     private String name1;
    4.     public int a;
    5.     public void fun() {
    6.         System.out.println("hello "+name1);
    7.     }
    8.  
    9.     public void setMyName(String myName) {
    10.         name1 = myName;
    11.     }
    12.     public String getMyName() {
    13.         return name1;
    14.     }
    15.  
    16.     public int getAge() {
    17.         return age;
    18.     }
    19.  
    20.     public void setAge(int age) {
    21.         this.age = age;
    22.     }
    23.  
    24.     @Override
    25.     public String toString() {
    26.         return "Person{" +
    27.                 "age=" + age +
    28.                 ", name='" + name1 + '\'' +
    29.                 '}';
    30.     }
    31. }
    32. public class Dome {
    33.     public static void main(String[] args) {
    34.         new Person().fun();
    35.         System.out.println(new Person().a);
    36.     }
    37. }

     匿名对象在我们这里只能使用一次如上述，我们在使用的时候不用创建新的引用就是使用该类的方法或者变量，一般在只使用一次的时候比较方便，如果使用该类的方法或者变量比较多的话，还是建议new一个对象使用起来比较方便。

  • 相关阅读:
    Java正则表达式解析复杂跨行日志
    【论文阅读】Semi-supervised Sequence Learning半监督序列学习
    命令执行无回显的判断方法及dnslog相关例题的讲解
    新一代前端应该使用的“开发套餐“
    SpringCloud学习笔记-Eureka服务的搭建
    店外营销吸睛，店内体验升级丨餐饮品牌如何「吃」透数据？
    MYSQL中varchar和TEXT
    轻量级RPC分布式网络通信框架设计——muduo网络部分解析
    Python中的一些有趣的内置函数
    Vue生命周期函数相关——笔试/面试题
  • 原文地址：https://blog.csdn.net/m0_56911284/article/details/126492392