Java 构造方法

• 对象的属性赋值与读值   先在main方法里写一个类及相关的属性

public class Person01 {
    /**
     * 昵称
     */
    String nickname;
    /**
     * 性别  0女生  1男生
     */
    int gender;
    /**
     * 年龄
     */
    int age = 18;
}

• 写完后在Test里面写测试 可以发现 类名点属性名无法调用 需要实例化对象后才可以调用

public class Person01Test {
    @Test
    public void test0(){
        Person01 person01 = new Person01();
        Person01 person02 = new Person01();
    }
}

• 下面是具体案例 

public class Person01Test {
    @Test
    public void test0(){
        Person01 person01 = new Person01();
        Person01 person02 = new Person01();
        System.out.println(person01.nickname); //此时nickname没有值  默认值为null
        System.out.println(person02.nickname);
        System.out.println(person01.gender == 1? "小伙" : "姑娘");
        System.out.println(person02.gender == 0? "小伙" : "姑娘");
        System.out.println(person01.age);
        System.out.println(person02.age);
        System.out.println("++++++++++++++++++++++++++++++++"); 
        person01.nickname = "李昊哲";
        person02.nickname = "李哲";
        System.out.println(person01.nickname);
        System.out.println(person02.nickname);
        person01.gender = 1;
        System.out.println(person01.gender == 1? "小伙" : "姑娘");
        person01.age = 40;
        person02.age = 30;
        System.out.println(person01.age);
        System.out.println(person02.age);
    }
}

 

•  访问修饰符  public  protected  default  private

在java中 可以使用控制变量来保护对类  变量  方法  和构造方法的访问

public： 对所有类可见   适用对象 ：类   接口  变量  方法

protected： 对同一包内的类和所有子类可见      适用对象：变量   方法   注意：不能修饰内部类

default(默认  啥也不写)： 在同一包内可见   不使用任何修饰符    

private：在同一类内可见   适用对象：变量   方法   注意：不能修饰内部类

• 当类的属性用private修饰时   想要调用的话需要用到  set  get  写法  快捷方法是alt+insert 

public class Person02 {
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 性别  0女生  1男生
     */
    private int gender;
    /**
     * 年龄
     */
    private int age = 18;
    public void setNickname(String name){
        nickname = name;
    }
    public String getNickname(){
        return nickname;
    }
    public void setGender(int sex){
        gender = sex;
    }
    public int getGender(){
        return gender;
    }
    public void setAge(int newage){
        age = newage;
    }
    public int getAge(){
        return age;
    }
}

• 调用方法 ：要先用set赋值   再调用

public class Person02Test {
    @Test
    public void test0(){
        Person02 person01 = new Person02();
        Person02 person02 = new Person02();
        person01.setNickname("李昊哲");
        person02.setNickname("李哲");
        person01.setGender(0);
        person02.setGender(1);
        person01.setAge(30);
        person02.setAge(38);
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
        System.out.println(person01.getGender() == 0? "小伙" : "姑娘");
        System.out.println(person02.getGender() == 0? "小伙" : "姑娘");
        System.out.println(person01.getAge());
        System.out.println(person02.getAge());
    }
}

•  当参数名与属性名一致时，需要进行修改     加个this

public class Person03 {
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 性别  0女生  1男生
     */
    private int gender;
    /**
     * 年龄
     */
    private int age = 18;
    public void setNickname(String nickname){
        this.nickname = nickname;
    }
    public String getNickname(){
        return nickname;
    }
    public void setGender(int gender){
        this.gender = gender;
    }
    public int getGender(){
        return gender;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

•  调用方法与上一个无区别
• 方法名与类名相同  方法体没有返回值 但是在方法声明的时候却不需要使用void修饰的方法  称之为构造

构造方法的作用  用于初始化对象  为对象的属性赋值
没有参数的构造方法  称为无参构造方法   再代码中没有编写过构造方法  jvm会在执行对象初始化时   帮助程序追加无参构造  

当一个类中没有无参构造  也没有参构造时  jvm会自动生成一个无参构造  当一个类存在有参构造时  jvm不会追加无参构造    因此一般情况下   一定要自己手写一个无参构造方法

无参构造实例：

public class Person06 {
    public Person06(){
        System.out.println("我是Person06的无参构造");
    }
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 性别  0女生  1男生
     */
    private int gender;
    /**
     * 年龄
     */
    private int age = 18;
}

public class Person06Test {
    @Test
    public void test0(){
        Person06 person06 = new Person06();
    }
}

 有参构造实例：

public class Person07 {
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 性别  0女生  1男生
     */
    private int gender;
    /**
     * 年龄
     */
    private int age = 18;
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public int getGender() {
        return gender;
    }
    public void setGender(int gender) {
        this.gender = gender;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person07(){
        System.out.println("我是Person07的无参构造");
    }
    public Person07(String nickname,int gender,int age){
        System.out.println("我是Person07的全参构造");
        this.nickname = nickname;
        this.gender = gender;
        this.age = age;
    }
}

public class Person07Test {
    @Test
    public void test0(){
        Person07 person07 = new Person07();
        person07.setNickname("李昊哲");
        person07.setGender(1);
        person07.setAge(30);
        System.out.println(person07.getNickname());
        System.out.println(person07.getAge());
        System.out.println(person07.getGender());
    }
    @Test
    public void test01(){
        Person07 person07 = new Person07("超大大",0,18);  // 在实例化对象时会调用有参构造
        System.out.println(person07.getNickname());
        System.out.println(person07.getAge());
        System.out.println(person07.getGender());
    }
}

•  构造代码块   

 {}   称为代码块或代码段
 只有一对  {}  的我们称为构造代码段  或构造代码块
 构造代码块在构造方法之前先执行   优先级高
 类  每次被实例化的过程中都会调用构造代码块 

实例

public class Person10 {
    /**
     * 昵称
     */
    String nickname;
    /**
     * 性别  0女生  1男生
     */
    int gender;
    /**
     * 年龄
     */
    int age = 18;
    public Person10(){
        System.out.println("我是无参构造方法");
    }
    public Person10(String nickname, int gender, int age) {
        System.out.println("我是有参构造方法");
        this.nickname = nickname;
        this.gender = gender;
        this.age = age;
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public int getGender() {
        return gender;
    }
    public void setGender(int gender) {
        this.gender = gender;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    {
        System.out.println("我是构造代码块");
    }
}

 

•  静态代码块          使用static修饰的代码块  我们称为静态代码块 

  当 类 加载时就会执行静态代码块  并且静态代码块  仅执行一次  不可多次执行
  构造代码块  是在类实例化过程中执行
  执行优先级:  静态代码块>>>>>构造代码块>>>>>>构造方法 

实例

public class Person11 {
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 性别  0女生  1男生
     */
    private int gender;
    /**
     * 年龄
     */
    private int age = 18;
    public Person11(){
        System.out.println("我是无参构造方法");
    }
    public Person11(String nickname, int gender, int age) {
        System.out.println("我是有参构造方法");
        this.nickname = nickname;
        this.gender = gender;
        this.age = age;
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public int getGender() {
        return gender;
    }
    public void setGender(int gender) {
        this.gender = gender;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    {
        System.out.println("我是构造代码块");
    }
    static {
        System.out.println("我是静态代码块");
    }
}