多态、抽象类及冒泡排序

一、抽象类

在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

/*
    抽象类
*/
public abstract class Animal {
    //抽象方法
    public abstract void eat();
}

特点：1.抽象类和抽象方法必须使用abstract关键字修饰

                public abstract class 类名（）；

                 public abstract viod eat();

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类不能实例化，如果要实例化，参照多态的方式，通过子类对象实例化，这叫抽象类多态

4.抽象类的子类：要么重写抽象类中的所有抽象方法，要么是抽象类

抽象类的成员特点：

1.成员变量：可以是常量，也可以是变量

2.构造方法：有构造方法，但是不能实例化，用于子类访问父类数据的初始化

3.成员方法：抽象方法限定子类必须完成某些动作；非抽象方法提高代码复用性

二、接口

1.接口用关键字interface修饰：public interface 接口名{}

2.类实现接口用implements表示：public class 类名 implements 接口名{}

3.接口不能实例化，如果要实例化，参照多态方式，通过实现类对象实例化，这叫接口多态

多态的形式：具体类多态，抽象类多态，接口多态

多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向子（类/实现）类对象

4.接口的实现类：要么重新写接口中的所有抽象方法；要么是抽象类

/接口/
public interface Jumpping {
    public abstract void jump();
}
/子类/
public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫会跳高");
    }
}
/测试类/
public class HelloWorld {
    public static void main(String[] args) {
        Jumpping j=new Cat();
        j.jump();
    }
}

接口的成员特点：

1.成员变量：只能是常量，默认修饰符：public static final

2.构造方法：接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

                      一个类如果没有父类，默认继承自Object类

3.成员方法：只能是抽象方法，默认修饰符：public abstract

类和接口的关系：

1.类和类的关系：继承关系，只能单继承，但是可以多层继承

2.类和接口的关系：实现关系，可以单实现多实现，还可以在继承一个类的同时实现多个接口

3.接口和接口的关系：继承关系，可以单继承，也可以多继承

三、形参和返回值

1.类名作为形参和返回值

方法的形参是类名，其实需要的是给该的对象

方法的返回值是类名，其实返回的是给该的对象

2.抽象类名作为形参和返回值

方法的形参是抽象类名，其实需要的是给该抽象类的子类对象

方法的返回值是抽象类名，其实返回的是给该抽象类的子类对象

public class Cat {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class CatOperate {
    public void useCat(Cat c) {
        c.eat();
    }

    public Cat getCat() {
        Cat c = new Cat();
        return c;
    }
}
public class CatDemo {
    public static void main(String[] args) {
        CatOperate co = new CatOperate();
        Cat c = new Cat();
        co.useCat(c);

        Cat c2 = co.getCat();
        c2.eat();
    }
}

3.接口名作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回的是该接口的实现类对象

四、内部类

1.概述：就是在一个类中定义一个类。例如在一个类A的内部定义一个类B，B就被成为内部类

2.内部类的访问特点

内部类可以直接访问外部类成员，包括私有

外部类要访问内部类成员，必须创建对象

3.成员内部类

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象

例如：Outer.Inner oi=new Outer().new Inner();

局部内部类：局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用，该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类：前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

                        本质:是一个继承了该类或者实现了该接口的子类匿名对象

public class JumppingOperator {
    public void method(Jumpping j){
        j.jump();
    }
}

public interface Jumpping {
    void jump();
}
public class JumppingDemo {
    public static void main(String[] args) {
        JumppingOperator jo=new JumppingOperator();
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
    }
}

 new 类名或者接口名（）{

                重写方法；

}

 五、API

1.Math

2.System:

System.exit(0);

System.currentTimeMillis();

3.Object类常用方法

方法名	说明
public String toString()	返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(Object obj)	比较对象是否相等，默认比较地址，重写可以比较内容，自动生成

六、冒泡排序

public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = {32, 54, 86, 12, 20,56,89,105,2};
        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(arrayToString(arr));
    }
    public static String arrayToString(int[] arr) {
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
               sb.append(arr[i]);
               sb.append(",");
            }
        }
        sb.append("]");
        String s= sb.toString();
        return s;
    }

}

七、Arrays

Arrays类包含用于操作数组的各种方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = {32, 54, 86, 12, 20, 56, 89, 105, 2};
        System.out.println("排序前："+ Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后："+Arrays.toString(arr));
    }
}