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的子类,他们在类型上兼容



posted @   若你  阅读(39)  评论(0编辑  收藏  举报

喜欢请打赏

扫描二维码打赏

了解更多

点击右上角即可分享
微信分享提示