java学习中，匿名函数、构造方法、构造代码块、构造方法中调用构造方法（java 学习中的小记录）...

待我称王封你为后i 2023-08-17 16:17 140阅读 0赞

**java学习中，匿名函数、构造方法、构造代码块、构造方法中调用构造方法（java 学习中的小记录）**

**![1045520-20161028121136703-1594984301.gif][]作者：王可利（Star·星星）**

**匿名函数**

**匿名对象：没有名字的对象**

**匿名对象使用的注意点：**

1.一般不会用匿名对象给属性赋值，无法获取属性值，每次new 都是一个新的对象。

2.匿名对象永远都不可能是一个对象。

如：person new（）.name = “星星”；**是不行的**

**匿名对象的好处：书写简单。**

**匿名对象使用的场景：**  
1.如果一个对象调用一个方法一次的时候，就可以用匿名对象来调用.  
 2.可以作为实际参数在方法中调用

--------------------

**构造方法**  
**Object-C 中自定义初始化方法：创建对象的时候 init 就调用这些方法；**  
1.可以在对象创建的时候初始化属性值。  
 2.创建对象的时候 只调用了一次方法。

**java 中 ，这个方法叫构造方法**

**构造方法的作用：给对象进行初始化，对象创建时初始化属性值。**

**创建构造方法：**

1.构造方法没有返回类型，方法名和类名保持一致。

2.构造方法不是我们手动调用的，是对象被创建的时候jvm（java虚拟机）调用的。

3.如果一个类我们没有给它定义构造方法，jvm（java虚拟机）在编译的时候 会给这个类默认添加一个无参构造方法。

4.如果自己定义了构造方法，那么jvm不会再创建无参构造方法。

5.创建对象的时候，有几个参数，就要有相应的构造方法，也是对应的要有几个参数。

格式：

1.修饰符 类名（参数列表）｛｝

2.直接类名 （参数列表）｛｝

代码如下

1 class Person{
     2     //公有属性
     3     String name;
     4     int age;
     5     
     6     //创建一个构造方法（有两个参数）
     7     public Person(String n,int a){
     8         name = n;
     9         age = a;
    10     }
    11     //无参构造方法
    12     public Person(){
    13         
    14     }
    15     
    16     //行为
    17     public void study(){
    18         System.out.println(age+"岁的"+name+"正在学习");
    19     }
    20 }
    21 public class Star_gzff {
    22     
    23     public static void main(String[] args) {
    24         //创建一个Person对象
    25         Person p = new Person("星星",12);//这里传的是两个参数的那个构造方法 26         //调用普通的方法-工作
    27         p.study();
    28         
    29         //没有无参构造方法这里会出错
    30         Person p1 = new Person();//这里传的是无参数的构造方法 31         p1.name = "小明";
    32         p1.study();
    33     }
    34 }

--------------------

**方法重载**

**java中，方法是可以重名的，我们把这种重名的方法叫 方法的重载。**

**使用方法重载注意的地方：**

1.方法名一样才叫方法重载。

2.任何方法（普通方法，构造方法）都可以实现方法重载。

3.参数列表要保证顺序 或者 个数是不一样的。

如 ：Person （String a , int b）;

Person （ int b, String a）;//顺序不一样

Person （String a , int b，String c）;//个数不一样

--------------------

**构造代码块**

**代码块分为三类：**

1.构造代码块

2.局部代码块：写在方法中，也是以大括号来表示

3.静态代码块

**在上面的构造方法中，构造方法是可以调用普通方法的，在创建对象的同时就使用这个普通方法，不需要后期对象再调用方法。**

如：

public Person(String n,int a)\{   
                 name = n;  
                 age = a;  
                 study（）;//调用普通的方法  
      \}

**如果我们有很多的这样的构造方法（无参的，一个参数的，两个参数的...），每一个都要调用这个方法，代码就会显得复杂麻烦，于是就有了构造代码块。**

**代码块作用：****给对象统一初始化。（对象创建之前都会走这个方法）**

**构造代码块的格式：｛｝ 就一个大括号。。**

**代码分析：**

1 class Person{
     2     //公共属性
     3     String name;
     4 
     5     //构造代码块
     6     {
     7         age = 18;
     8     }
     9     //创建一个构造方法
    10     public Person(String n,int a){
    11         name = n;
    12         age = a;
    13     }
    14     
    15     int age = 20;
    16     
    17     public void study(){
    18         
    19         System.out.println(age+"岁的"+name+"在学习");
    20     }
    21 }
    22 
    23 public class Star_gzdmk {
    24     
    25     public static void main(String[] args) {
    26         
    27         Person p = new Person("星星",12);
    28         p.study();
    29     }
    30 }

**构造代码块使用注意点总结：**

1.构造代码块必须写在成员变量（属性）的位置。

2.对象创建之前都会走这个方法。

3.java中编译器编译java源文件的时候，会把成员变量的声明放到最前面。

4.成员变量的初始化都是在构造方法中执行的，一旦经过java编译器编译，构造代码块的方法会移到构造函数中执行，放在构造函数的最前面执行。

5.如果没有构造方法，只有成员变量初始化和构造代码块，按照当前代码的顺序来执行。

**在普通方法里面，如果添加一个局部变量，名字和属性的名字一样的话：**

**System.out.println(name)，这里的那么就是 局部变量的 name。**

**如果用了this关键字的话，System.out.println(this.name);就是构造方法里面的name。**

**在构造方法里面，传入的参数名字和属性的名字一样的话：如：name = name；//拿到的两个name都是局部变量**

**这时要写 this.name = name;//拿到的第一个name才是属性**

**this关键字：**

1.代表所属方法的调用对象，和oc中的 self 相似。

2.如果成员变量和局部变量重名，在方法中的默认调用局部变量（就近原则），通过this可以让方法的调用成员变量。

3.如果方法中不存在与成员变量重名的局部变量，java编译器就会默认给变量前面加一个this。

--------------------

**构造方法中调用构造方法**

**构造方法是可以调用普通方法（实例方法）。**

**构造方法中也是可以调用构造方法的。**

**问题代码如下：**

class Student{
        //公有属性
        String id;
        String name;
        String classNum;
        String sex;
        int age;
        //创建构造方法
        public Student(String id,String name,String classNum,String sex,int age){
            this.name = name;
            this.id =id;
            this.classNum = classNum;
            this.sex = sex;
            this.age = age;
        }
        //重载构造方法，只写四个参数的
        public Student(String id,String name,String classNum,String sex){
            this.name = name;
            this.id =id;
            this.classNum = classNum;
            this.sex = sex;
        }
        //重载构造方法，只写三个参数的
        public Student(String id,String name,String classNum){
            this.name = name;
            this.id =id;
            this.classNum = classNum;
        }
        //普通方法
        public void Student(){
            
        }
    }

**这样子写代码的话就会显得代码很复杂，我们在这个时候就可以尝试使用构造方法之间的调用。**

比方说：4个参数的构造方法包含了3个参数的构造方法，我只需要在四个参数的构造方法里面调用3个参数的构造方法，在从中添加一个自己与三个参数不同的一个参数就可以简化代码了。

**解决第一步的代码如下：**

class Student{
        //公有属性
        String id;
        String name;
        String classNum;
        String sex;
        int age;
        //创建构造方法
        public Student(String id,String name,String classNum,String sex,int age){
            Student(id,name,classNum,sex);//四个参数 this.age = age;
        }
        //重载构造方法，只写四个参数的
        public Student(String id,String name,String classNum,String sex){
            Student(id,name,classNum);//三个参数 this.sex = sex;
        }
        //重载构造方法，只写三个参数的
        public Student(String id,String name,String classNum){
            this.name = name;
            this.id =id;
            this.classNum = classNum;
        }
        //普通方法
        public void Student(){
            
        }
    }

**但是如果你这样子调用的话会出现一个问题，你调用的不是构造方法，而是普通方法。**

总结：直接使用方法名来调用方法，调用的是普通方法，不会是构造方法。

**最后的解决方法，代码如下：**

class Student{
        //公有属性
        String id;
        String name;
        String classNum;
        String sex;
        int age;
        //创建构造方法
        public Student(String id,String name,String classNum,String sex,int age){
            this(id,name,classNum,sex);
            this.age = age;
        }
        //重载构造方法，只写四个参数的
        public Student(String id,String name,String classNum,String sex){
            this(id,name,classNum);
            this.sex = sex;
        }
        //重载构造方法，只写三个参数的
        public Student(String id,String name,String classNum){
            this.name = name;
            this.id =id;
            this.classNum = classNum;
        }
        //普通方法
        public void Student(){
            
        }
    }

**构造方法调用的总结：**

1.直接使用方法名来调用方法 调用的是普通的方法，不会将这个方法作为构造方法。

如：Student（name,id,classNum,sex）;

2.如果在方法名前面添加this ，也是错误的。

如：this，Student（name,id,classNum,sex）;

3.正确的调用方法应该是直接一个this（）来调用构造方法。而且要是第一个语句，否则会报错。

如：this（name,id,classNum,sex）;

this.id = id;

4.不要在两个构造方法之间相互调用构造方法。会导致死循环。

如：this（name,id,classNum,10）;//传了一个常量

转载于:https://www.cnblogs.com/StarKL/p/6114459.html

[1045520-20161028121136703-1594984301.gif]: /images/20230810/ace88724458b49bcaebdbebc1639a2ec.png