Java第六课

Java第六课

一、排序

• 冒泡排序

  public class C242 {
      public static void main(String[] args) {
          int[] arr = new int[5];
          Random random = new Random();
          for (int i = 0; i < arr.length; i++) {
              arr[i] = random.nextInt(20);
          }
          System.out.println(Arrays.toString(arr));
          for (int i = 0; i < arr.length - 1; i++) {
              for (int j = 0; j < arr.length - i - 1; j++) {
                  if (arr[j]>arr[j+1]) {
                      int temp = arr[j];
                      arr[j] = arr[j + 1];
                      arr[j+1] = temp;
                  }
              }
          }
          System.out.println(Arrays.toString(arr));
      }
  }

• 选择排序

• 快速排序

二、重载

• 重载的必要条件：

  • 在一个类中

  • 方法名相同

  • 参数列表不同（个数不同或类型不同或顺序不同）

• 方法名相同，说明他们处理的业务应该是类似的，不同的是处理的对象略有不同，此时就需要重载，如果不重载也可以，就是给方法起不同的名称。

public class C243 {
    public void say(String msg) {
        System.out.println("String" + msg);
    }
​
    public int say(int num) {
        return num++;
    }
​
    public static void main(String[] args) {
        C243 c243 = new C243();
        System.out.println(c243.say(1));
    }
}

三、传参

public class C243 {
    public static void main(String[] args) {
        int num = 1;
        C243 c243 = new C243();
        c243.add(num);
        System.out.println("num=" + num);
    }
​
    /**
     * 对参数num加1
     * @param num
     */
    public void add(int num) {
        num++;
    }
}

public class C244 {
    public static void main(String[] args) {
        // 栈中student的地址是100，它里面保存的是name1学生的堆地址2000
        Student student = new Student(1, "name1");
        C244 c = new C244();
        c.changeStudent(student);
        System.out.println(student.getName());
    }
​
    /**
     * 改变学生姓名
     * @param student
     */
    public void changeStudent(Student student) {
        student.setName("new name");
    }
}

对于原始类型的参数，传入的是变量的值，对于引用类型的参数，传入的是对象的地址。

不一样：一个是数值，一个是地址

一样：都是变量中的值

public class C245 {
    public static void main(String[] args) {
        // 栈中student的地址是100，它里面保存的是name1学生的堆地址2000
        Student student = new Student(1, "name1");
        C245 c = new C245();
        c.changeStudent(student);
        System.out.println(student.getName());
    }
​
    /**
     * 改变学生姓名
     * @param student
     */
    public void changeStudent(Student student) {
        student = new Student(2, "name2");
    }
}

变量，参数，指针

public class C246 {
    public static void main(String[] args) {
        String name = "Tom";
        C246 c = new C246();
        c.change(name);
        System.out.println(name);
    }
​
    public void change(String msg) {
        // msg += "hello";
        // String是不变的，当让String变化时，它就会产生一个新的String
        msg.concat("hello");
        // 相当于 msg += "hello";
    }
}

四、继承和多态

• 子类继承父类，高效

1. 子类不用写重复的代码

2. 维护代码不用对相似（相同）代码进行多处维护。

3. 开发和维护都高效

缺点：打破了封装，原来不继承是无法访问父类的成员，继承后就可以访问了

创建子类时，首先要创建它依赖的父类对象，是一个依赖链，耗费时间空间

当继承层次多时，使得代码阅读困难

public class A {
    public A() {
        System.out.println("A init");
    }
    public static void main(String[] args) {
        B b = new B();
    }
}
class B extends A {
    public B() {
        System.out.println("B init");
    }
}

Java类文件中可以同时写多个class，但是只能有一个类是public，并且这个类名和文件名要一致。

如果一个java类文件只有一个类，并且这个类不是public的，则类名和文件名可以不一致。

类中的游离语句会先执行，再执行构造方法，在生成的class文件中看到游离块实际是放在构造方法的前部分。

类中的代码，在类中只能定义变量和赋值，无法写其他代码，比如：打印，计算等，这些代码都要写在方法中，而游离块中是不做限制的。原因是游离块最终还是在构造方法中。

五、重写

子类继承父类

子类中的方法名，方法参数列表必须和父类完全相同，方法返回类型要兼容。

方法的访问修饰符必须大于等于父类的（可以发扬光大，不可失传）

protected(父类)

子类就必须是procted或public

@Override 注解：说明存在重写的现象，可以强制编译器进行检查，检查方法是否重写正确

public class Father {
    protected void say() {
        System.out.println("你好");
    }
​
    public void work() {
        System.out.println("work in father");
    }
​
    public static void main(String[] args) {
        Son son = new Son();
        son.say();
        son.work();
    }
}
​
class Son extends Father {
    @Override
    protected void say() {
        System.out.println("hello");
    }
}

父类中的方法被子类继承后，又重新定义就是重写，表现出子类重写后的现象。

父类方法和子类方法发生重写后，子类方法的返回类型必须和父类方法的返回类型兼容（不需要完全相同）

    protected Father getObject() {
        return this;
    }
    @Override
    protected Son getObject() {
        return this;
    }

重写方法getObject子类中返回的是Son，而Son是Father的子类，他们在类型上兼容