JAVA（二）

冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        long startTime=System.nanoTime();//开始计算时间的位置
        
        int[] array = {12,45,65,79,456};

        for (int i = 0;i<array.length-1;i++){
            for(int j =0;j<array.length-1-i;j++){
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }

        long endTime=System.nanoTime();//结束计算时间的位置
        System.out.println("\n循环完用时："+(endTime-startTime) + "ns");
        
//        for (int i : array){
//            System.out.println(i);
//        }
        for (int i = 0;i<array.length;i++){
            System.out.println(array[i]);
        }

    }
}

选择排序

public class SelectionSort {
    public static void main(String[] args) {
//        long startTime=System.nanoTime();//开始计算时间的位置

        int[] array = {12,45,65,79,456};

        // 需要遍历获得最小值的次数
        for (int i = 0; i < array.length; i++) {
            int min = i;// 用来保存最小值得索引
            // 寻找第i个小的数值
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[min]) //找到最小的数
                    min = j; //将最小数的索引保存
            }
            int temp = array[min];
            array[min] = array[i];
            array[i] = temp;
        }
//        long endTime=System.nanoTime();//结束计算时间的位置
//        System.out.println("\n循环完用时："+(endTime-startTime) + "ns");

        for (int i : array){
            System.out.println(i);
        }
    }
}

方法

public class TEST1 {

    private int id;
    private int age;

    public TEST1(int id, int age) {
        this.id = id;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }



    public static void man(){
        //return;
        System.out.println("I'm a man.");
    }
    public static void person(int age){
        System.out.println("I'm " + age + " years old.");
    }
    public static int testData(int i, int j){
        //System.out.println(i + j);
        return i+j;
    }
    public static int[] method(int i,int j) {
        int[] array = {i,j};
        return array;
    }
    public static TEST1 method2() {
        TEST1 stu = new TEST1(1,20);
        return stu;
    }



    public static void main(String[] args) {
        man();

        person(15);

        int sum = testData(2,3);
        System.out.println(sum);

        int[] arr = method(10,20);
        System.out.println(arr[1]);

        TEST1 msg = method2();
        System.out.println(msg.getId() + " " + msg.getAge());
    }
}

方法声明格式

[修饰符1 修饰符2 …] 返回值类型 方法名（形式参数列表）{

​ JAVA语句…；

}

返回值类型

1. 基本类型
2. 数组
3. 字符串
4. 自定义的类

形参实参

形参

用来接收调用方法时传递的参数。只有在被调用的时候才分配内存空间，一旦调用结束，就释放内存空间。因此仅仅在方法内有效。

实参

传递给被调用方法的值，预先创建并赋予确定值。

构造方法（构造函数）

• 具有与类名相同的名称

• 不需要返回值（如果有，则不是构造方法，而是和构造方法同名的成员方法）

• 不要求声明返回值类型

• 不能被static、final、synchronized、abstract和native修饰

• 构造方法不能被子类继承，所以用final和abstract修饰没有意义

• 构造方法的调用时机与一般的方法不同。一般的方法是在需要时才调用，而构造方法则是创建对象时自动调用，并执行构造方法的内容。因此，构造方法无需在程序中直接调用，而是在对象产生时自动执行。

• 可利用构造方法对对象的数据成员做初始化的赋值

• 如果在类中没有声明任何的构造方法，系统会自动为类加入一个无参的且什么都不做的构造方法，类似于下面的代码：

  public Person(){
  
  }
  
  

public class Demo {

    private int x;

    public Demo() { // 不带参数的构造方法



    }

    public Demo(int x) { //带参数的构造方法

        this.x=x;

    }

    public int Demo(int x) { //不是构造方法

        return x++;

    }

}

变量

成员变量

• 可以不对其初始化

• 作用范围为整个类体

成员变量和局部变量的区别

• 成员变量

在类体里面定义的变量叫做成员变量；

如果在变量有static关键字修饰，就叫作静态变量或类变量；

如果该变量没有static关键字修饰，就叫作非静态变量或实例变量；

• 局部变量

方法内定义的变量、形参、代码块中定义的变量都叫做局部变量；

• 成员变量可以不对其初始化，局部变量不可以
• 成员变量在所在类被实例化后，存在堆内存中；局部变量在所在方法调用时，存在栈内存空间中。

类

组成

成员变量+方法

public class test2 {
//    int age;

    public static void main(String[] args) {
        Stu a = new Stu();
        Stu b = new Stu("小明",1,12);
    }

}

class Stu{

//    成员变量
    String name;
    int id;
    int age;

    public Stu(String name, int id, int age) {
        
    }

    public Stu() {
        
    }

    //声明方法
    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

重载

定义

如果同一个类中包含了两个或两个以上方法名相同，方法参数的个数、顺序或者类型不同的方法，则成为方法的重载

判断依据

1. 在同一个类中
2. 方法名相同
3. 方法的参数的个数，顺序或类型不同
4. 方法的返回类型可以相同也可以不同

public class test3 {
    public static void main(String[] args) {
        double max = max(134.5,34.2);
        System.out.println(max);
    }

    public static int max(int a,int b){
        int num = 0;
        if(a==b){
            System.out.println(a = b);
        }

        if(a>b){
            num = a;
        }else{
            num = b;
        }
        return num;
    }
    public static double max(double a,double b){
        double num = 0;
        if(a==b){
            System.out.println(a = b);
            return 0;
        }

        if(a>b){
            num = a;
        }else{
            num = b;
        }
        return num;
    }

}

构造方法中也有重载

内存解析

stack栈

• 存放基本类型的数据和对象的引用，即存放变量。
• 如果存放的是基本类型数据（非静态变量），则直接将变量名和值存入stack中
• 如果是引用类型，则将变量名存入栈，然后指向它new出的对象（存放在堆中）

heap堆

• 存放new出来的数据

data segment

• 静态域

  • 存放在对象中用static定义的静态成员

• 常量池

实例

静态变量与非静态变量

    public static void main(String[] args) {
        String stra = "qwe";
        String strb = "qwe";

        System.out.println(stra == strb);
    }

    public static void main(String[] args) {
        String stra = new String("qwe");
        String strb = "qwe";

        System.out.println(stra == strb);
    }