Java-构造函数与this、static关键字

阿伍.

已于 2022-11-16 21:43:36 修改

阅读量277

点赞数 5

分类专栏： Java 全过程学习文章标签： java 开发语言

于 2022-10-30 20:09:29 首次发布

本文链接：https://blog.csdn.net/m0_71673753/article/details/127599768

版权

Java 全过程学习专栏收录该内容

14 篇文章 4 订阅

订阅专栏

1.构造方法

构造方法分为无参构造与有参构造，无参构造在类的创建就被系统默认创建，所有我们在没有创建构造方法就可以使用new调用构造函数。有参构造需要我们自己，创建完后有参构造会覆盖无参构造

1.什么是构造方法

1.构造方法是用来实现类的实例化(创建对象)。它分为有参构造和无参构造，无参构造只会单纯创建对象，有参构造会在对象创建的同时对其属性进行赋值

2.构造方法没有返回值类型，也不需要写返回值类型

3.构造方法名称必须与类名相同

4.构造方法没有具体的返回值【其返回值是创建对象的地址】

5.构造方法的调用需要用new操作符，普通方法通过【类名.方法】或者【引用.方法】

2.语法格式

语法格式：
        【修饰符】构造方法名(){
             //代码块
         }

例如：    public Student(int a,String b){
              age=a;
              name=b;
         }



注释：1.修饰符为public

      2.构造方法名与类名相同

3.构造方法实例演示

package 集成开发;

public class Structure {
    public static void main(String[] args) {
        //调用构造方法创建同时初始化对象
        Structuretest Str1=new Structuretest(20,"小王");
        Structuretest Str2=new Structuretest(180,"小李");
        //输出初始化值
        System.out.println(Str1.getAge());//20
        System.out.println(Str2.getAge());//180
    }
}

class Structuretest{
    private int age;//年龄
    private String name;//姓名
//Structuretest类的构造方法
    public Structuretest(int a,String b){
        age=a;
        name=b;
    }
//get与set方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0||age>150){
            System.out.println("你输入的年龄不合法");
            return;
        }
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
//注意：构造方法不会遵循你在set方法里面写的规范代码，比如上面我们规范在0~150，但是用构造方法可以写入180

4.构造方法的作用

构造方法的主要作用就是创建对象与创建的同时对对象进行初始化，一般情况下，我们都是先创建对象再对对象调用set方法进行赋值，但是有些情况下不允许我们这样，比如新生入学进行报名的时候就要对其年龄、姓名等属性进行赋值

5.构造方法的方法重载

一般来说，建议大家在写程序时将类的无参构造与有参构造都写上，以免在调用构造方法时无法用无参构造

//用户类
class Structuretest{
    private int age;//年龄
    private String name;//姓名
//有参构造
    public Structuretest(int a,String b){
        age=a;
        name=b;
    }
//无参构造
    public Structuretest(){

    }

//get与set方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0||age>150){
            System.out.println("你输入的年龄不合法");
            return;
        }
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


//测试类
public class Structure {
    public static void main(String[] args) {
        //调用构造方法创建同时初始化对象
        Structuretest Str1=new Structuretest(20,"小王");
        Structuretest Str2=new Structuretest();
        //输出初始化值
        System.out.println(Str1.getAge());//20
        System.out.println(Str2.getAge());//0
    }
}

注释：如果不写无参构造，那么Str2将必须在创建的同时为其初始化，加上后我们可以选择创建时
就对其初始化，也可以创建后再初始化

6.参数传递

当基本类型作参数传递时，在方法中对形参的修改不会影响实参
当引用类型作参数传递时，在方法中对形参的修改会修改实参的值

//基本数据类型做参数传递
public class Method {

public static int some(int a){
    a=300;
    return a;
}
 
//主方法
    public static void main(String[] args) {
        int num=100;
        System.out.println(some(num));//300
        System.out.println(num);//100
    }
}






//引用数据类型做参数传递
public class YouCan {
    int age;

    //构造方法
    public YouCan(){

    }
    public YouCan(int a){
        age=a;
    }
    //测试方法
    public static int some(YouCan a){
        a.age=100;
        System.out.println(a.age);//100
        return a.age;
    }
    //主方法
    public static void main(String[] args) {
        YouCan w=new YouCan(18);
        some(w);//100
        System.out.println(w.age);//100

    }
}

2.this关键字

前面在对类进行封装的时，可以看见我们的set方法里面使用了一个关键字this,this是对这个类的简化，它保存的是这个类所有对象的实例地址，也就是说所有的对象都有自己的this。接下来通过下面的代码了解this的使用

//源码
public class Student {
    private String name;//名字
    private String sex;//性别
    private int age;//年龄

//set方法
  public void setName(String name) {
        this.name = name;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
}



/*注释：很显然，出现this关键字的原因是方法中出现了局部变量与成员变量的冲突，如果将setName方法
中的this关键字去掉，代码如下*/
public void setName(String name) {
        name = name;
    }
//此时左边的name与右边的name是同一个局部变量，所以赋值不会成功，如果将代码改成下面这样
public void setName(String name1) {
        name = name1;
    }
/*此时左边为成员变量，右边为局部变量，虽然这样可以赋值成功，但是不建议将局部变量名称修改
为name1,而是继续使用name局部变量名称，为了区分变量类型，一般采用this.name表示成员变量，使用name表示局部变量*/

3.static关键字

1.静态代码块

语法格式：
        static {
          Java语句;
        }

静态代码块在类加载时执行，并且只能执行一次
静态代码块带类中可以写多个，且遵循自上而下的原则

话不多说看代码：

public class Student {

    static {
        System.out.println("欢迎使用此软件按");
    }
    public static void main(String[] args) {
        java.util.Scanner s=new java.util.Scanner(System.in);
        System.out.print("请输入用户名：");
        String a=s.next();
        System.out.print("请输入密码：");
        int b=s.nextInt();
        System.out.println("登陆成功");
    }
}

2.实例代码块

语法格式：
        {
          Java语句;
        }

实例代码块在创建对象时执行，每创建一个对象实例代码块就会执行一次
实例代码在类中可以写多个

public class Student {
    public Student(){
        System.out.println("我是在实例代码后面输出的");
    }
    {
        System.out.println("我最先输出");
    }

    public static void main(String[] args) {
        Student stu=new Student();
    }
}

/*结果：
我最先输出
我是在实例代码后面输出的*/

3.方法与属性有无static的区别

1.属性与方法如果有static我们不仅可以通过【类名.属性/方法名】访问，还可以通过【引用.属性\方法名】访问

2.属性与方法如果没有有static我们只可以通过【引用.属性\方法名】访问

3.如果方法有static，那么我们可以直接访问静态属性，但是不能直接访问动态属性

4.如果方法没有static,可以直接访问访问静态属性，也可以直接访问动态属性，因为动态方法只能通过对象访问，每个对象在动态方法中指代为this

public class A {
    static int age;
    int name;

    public static int some(){
        return 1;
    }
    public int move(){
       return 2;
    }

    public static void main(String[] args) {
        //我们可以通过【类名.属性/方法名】或者【引用.属性\方法名】访问带有static的属性和方法
        System.out.println(A.age);//0
        System.out.println(A.some());//1
        A a=new A();
        System.out.println(a.age);//0
        System.out.println(a.some());//1

        //但是没有static的属性与方法只能通过【引用.属性/方法】访问
        System.out.println(a.name);//0
        System.out.println(a.move());//2
        //通过【类.属性\方法】访问会报错
        System.out.println(A.name);
        System.out.println(A.move());
    }
}

总结：个人认为static关键字只是为类调用提供的一个方法，因为我们所有的属性与方法一般都是为对象准备的，都是不加static关键字的，所以只能通过引用访问，导致类无法直接访问到，但是加了static可以直接通过类访问到，也有说是为了让所有对象共享这个资源，比如static double pi=3.14,个人觉得赋予一个默认值与有无static关键字无关，去掉static给这个变量一样可以赋值，在你不更改这个值的情况下，所有的对象这个属性都是这个值