Java面向对象编程：构造方法与冒泡排序及static关键字应用-优快云博客

这篇博客介绍了Java中的构造方法和冒泡排序的应用，通过设计一个Student类，实现成绩从高到低的冒泡排序输出学生信息。同时讲解了static关键字的使用，包括创建静态方法创建运动员对象，强调了静态方法不能访问非静态成员或方法的原因，以及静态成员的特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、构造方法+冒泡排序

1.设计一个类Student，该类包括姓名、学号和成绩。在main方法中声明数组可以存多个学生信息，按照成绩从高到低的顺序冒泡输出姓名、学号和成绩信息。

学生类：Student.java

public class Student {
    private int sno;
    private String sname;
    private float scope;

    public Student(int sno, String sname, float scope) {
        this.sno = sno;
        this.sname = sname;
        this.scope = scope;
    }

    public int getSno() {
        return sno;
    }
    public void setSno(int sno) {
        this.sno = sno;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public float getScope() {
        return scope;
    }
    public void setScope(float scope) {
        this.scope = scope;
    }
}

测试类：Test.java

public class Test {
    public static void main(String[] args) {
        Student[] stus = new Student[5];
        stus[0] = new Student(1,"张三",60);
        stus[1] = new Student(2,"李四",80);
        stus[2] = new Student(3,"王五",70);
        stus[3] = new Student(4,"赵六",100);
        stus[4] = new Student(5,"孙七",90);

        Student temp;

        //冒泡排序
        for(int i = 0; i < stus.length; i++) {
            for(int j = stus.length-1; j > i; j--) {
                Student s1 = stus[j];
                Student s2 = stus[j-1];
                if(s1.getScope() > s2.getScope()) {
                    temp = stus[j];
                    stus[j] = stus[j-1];
                    stus[j-1] = temp;
                }
            }
        }
        //增强型for循环输出
        for(Student s : stus) {
            System.out.println(s.getSno()+","+s.getSname()+","+s.getScope());
        }
    }
}

输出：
4,赵六,100.0
5,孙七,90.0
2,李四,80.0
3,王五,70.0
1,张三,60.0

2、static关键字

2.创建一个运动员类，提供有静态的方法create，使用该静态方法创建对象，上限为10，并进行测试。

首先复习一下，静态方法的使用原则：1.静态方法不能访问非静态的成员或方法；2.静态方法中不能使用this和super关键字。

为什么？

静态方法随着类的加载而出现，随着类的消失而消失；所以静态方法是先于对象出现的，也是先于非静态方法出现，不能用静态方法调用后出现的非静态方法。
静态优先于对象，被所有对象共享；一般静态成员变量都是类中成员共有的属性或者方法；
因为静态先存在于内存，无法访问后来对象中的数据，所以静态无法访问非静态，也不能存在this，因为this代表当前对象，静态先于对象存在。

Player.java

public class Player {
    private static int count = 0;
    private Player() {
    }
    public static Player create() {
        Player p = null;
        if(count < 10){
            count++;
            p = new Player();
            System.out.println("创建第" + count + "个对象");
        }else{
            System.out.println("已达上限!");
        }
        return p;
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        Player.create();
        //第十一个对象
        Player.create();
    }
}