面向对象深入和数组深入

@面向对象深入和数组深入

抽象类的意义：为子类提供统一的，规范的模板，子类必须实现相关的抽象方法。

测试抽象类
要点：
1、父类没有实现
2、子类必须实现

示例代码：

 public abstract class Animal {
        public static void main(String[] args) {
            Animal animal = new Dog();
        }

第一：没有实现 第二：子类必须实现

abstract public void shout();
    public void run() {
        System.out.println("泡泡");
    }
}
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("汪汪");
    }
}

接口详解_多继承_面向接口编程。

测试接口以及实现类
示例代码：

public class TestInterface {
    public static void main(String[] args) {
        Volant volant = new Angel();
        volant.fly();
        System.out.println("######################");
        Angel angel;
        angel = new Angel();
        angel.fly();
        angel.helpOther();
    }
}

飞行接口

interface Volant{
    int FLY_HEIGHT = 100;
    void fly();
}
interface Honest{
    void helpOther();
}
class Angel implements Volant,Honest{
    @Override
    public void fly() {
        System.out.println("Angel.fly");
    }
    @Override
    public void helpOther() {
        System.out.println("Angel.helpOther");
    }//实现类可以实现多个父接口
}
class GoodMan implements Honest{

@Override
public void helpOther() {
    System.out.println("GoodMan.helpOther");
}
}
class BirdMan implements Volant{

@Override
public void fly() {
    System.out.println("BirdMan.fly");
}
}
public class TestInterface2 {
}

接口可以多继承：接口C继承接口A和B

interface A{
    void testa();
}
interface B{
    void testb();
}
    /*接口可以多继承：接口C继承接口A和B*/
    interface C extends A,B{
        void testc();
    }
    class Test implements C{

@Override
public void testa() {

}

@Override
public void testb() {

}

@Override
public void testc() {
	}
}

内部类_静态和非静态内部类_匿名内部类_方法内部类。

测试静态内部类
示例代码：

public class TestStaticInnerClass {
    public static void main(String[] args) {
        Outer2.Inner2 inner2 = new Outer2.Inner2();
    }
}
class Outer2{
    static class Inner2{
    }
}

测试非静态内部类
要点：
1、内部类必须寄存于一个外部类对象
2、可以直接访问外部类成员
3、外部类不能有静态方法 以及属性
示例代码：

public class TestInnerClass {
    public static void main(String[] args) {
        //创建内部类对象
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}
class Outer{
    private int age = 10;
    public void testOuter(){
        System.out.println("Outer.testOuter");
    }
    class Inner{
        int age = 20;
        public void show(){
            int age = 5;
            System.out.println("外部类的成员变量age"+Outer.this.age);
            System.out.println("内部类的成员变量age"+this.age);
            System.out.println("局部变量age"+age);
        }
    }
}

测试匿名内部类
示例代码：

public class TestAnoymousInnerClass {
    public static void test01(AA a){
        a.aa();
    }

public static void main(String[] args) {
    TestAnoymousInnerClass.test01(new AA(){

        @Override
        public void aa() {
            System.out.println("TestAnoymousInnerClass.main()newAA(){}.aa");
        }
    });
}
}
interface AA{
    void aa();
}

String类_常量池_字符串比较。

测试String类基本用法
示例代码：

 public class TestString {
    public static void main(String[] args) {
        String string;
        String string1 = "bcd";
        string = new String("abc");
        String string2 = "29"+30; //不是加法，是字符串连接符。
        System.out.println(string2);
        System.out.println("######################");
        String str10 = "gaoqi";
        String str11 = "gaoqi";
        String str12 = new String("gaoqi");
        System.out.println(str10 == str11);
        System.out.println(str12 == str11); //str11和str12不是一个对象
    //比较字符串通常使用equals
    System.out.println(str11.equals(str12));
}
}

测试String类的常用方法
示例代码：

public class TestString2 {
    public static void main(String[] args) {
       String string = "core Java";
        String string1 = "Core Java";
        System.out.println(string.charAt(3));//提取下表为三的字符
        System.out.println(string1.length());//字符串的长度
        System.out.println(string.equals(string1));//比较两个字符串是否相等
        System.out.println(string.equalsIgnoreCase(string1));//\比较字符串忽略大小写
        System.out.println(string.indexOf("Jave"));//判断是否含有字符串，第一次出现的位置
        System.out.println(string.replace('o','f'));//替换
        System.out.println(string);
        String string = "";
        String string1 = "How are you";
        String string2 = "   How old are you?  ";
        System.out.println(string1.startsWith("How"));//是否以How开头
        System.out.println(string1.endsWith("you"));//是否以you结尾
        System.out.println(string1.substring(4,7));//提取字符串：下表[4,7)不包括7
        System.out.println(string1.toLowerCase());//转小写
        System.out.println(string1.toUpperCase());//转大写
        System.out.println(string2.trim());//去除字符串首尾的空格，中间的不能去除
        System.out.println(string2);//因为String是不可变字符串，老的不会变
    }
}

数组的拷贝_插入和删除元素本质_数组扩容操作以及Arrays工具类的使用。

测试数组的拷贝_插入和删除元素本质_数组扩容操作
示例代码：

public class TestArrayCopy {
    public static void main(String[] args) {
        /*String[] string = {"阿里","腾讯","微软","百度","京东"};
        removeElement(string,1);
        System.out.println("#$###############");
        string = extendRange(string);*/
        //testBasicCopy();
        String[] strings = {"aa","bb","cc"};
        addElements(strings,2,"dd");
    }

public static void testBasicCopy() {
    String[] strings = {"aa", "bb", "cc", "dd", "ee"};
    String[] strings1 = new String[10];
    System.arraycopy(strings, 2, strings1, 6, 3);
    for (int i = 0; i < strings1.length; i++) {
        System.out.println(i + ":" + strings1[i]);
    }
}

//测试从数组中删除某个元素（本质上还是数组的拷贝）;删除数组中指定索引位置的元素，并将原数组返回
public static String[] removeElement(String[] strings, int index) {
    //String[] strings1 = new String[5];
    System.arraycopy(strings, index, strings, index - 1, strings.length - index);
    strings[strings.length - 1] = null;
    for (String a : strings) {
        System.out.println(a);
    }
    return strings;
}

//数组的扩容（本质：先定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中）
public static String[] extendRange(String[] strings) {
    //String[] strings = {"aa","bb","cc"};
    String[] strings1 = new String[strings.length + 10];
    System.arraycopy(strings, 0, strings1, 0, strings.length);//完全copy
    for (String aa : strings1) {
        System.out.println(aa);
    }
    return strings1;
}
//数组的插入
public static String[] addElements(String[] strings,int index,String string){
    String[] strings1 = new String[strings.length+1];
    System.arraycopy(strings,0,strings1,0,index);
    System.arraycopy(strings,index,strings1,index+1,strings.length-index);
    strings1[index] = string;
    for (String a:strings1
         ) {
        System.out.println(a);
    }
    return strings1;
}
}
public class TestArrays {
    public static void main(String[] args) {
        int[] a = {100,20,30,5,150,80,200};
        System.out.println(a);
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(a,31));//找到返回索引 找不到返回负数
    }
}

多维数组。

测试二维数组
示例代码：

 public class Test2DinmensionArray {
    public static void main(String[] args) {
        //int[] a= new int[3];
        //Car[] cars = new Car[3];
        int[][] a = new int[3][];
        a[0] = new int[]{20,30};
        a[1] = new int[]{10,15,80};
        a[2] = new int[]{50,60};
        System.out.println(a[1][2]);
        int[][] b ={{20,30,40,},{50,20},{100,200,300,400}};
        System.out.println(b[0][2]);
    }
}
//静态初始化二维数组
class Car{

}

多维数组存储表格数据
示例代码：

 public class TestAyyarTable {
    public static void main(String[] args) {
        Object[] emp1 = {1001,"金涛",18,"学生","2019-6-29"};
        Object[] emp2 = {1001,"金秀",19,"学生","2019-6-29"};
        Object[] emp3 = {1001,"金小花",18,"学生","2019-6-29"};
        Object[][] tableDate = new Object[3][];
        tableDate[0] = emp1;
        tableDate[1] = emp2;
        tableDate[2] = emp3;
        for (Object[] temp: tableDate
             ) {
            System.out.println(Arrays.toString(temp));
        }
    }
}

冒泡排序_优化排序。

测试冒泡排序
示例代码：

public class TestBubbleSort {
    public static void main(String[] args) {
        int[] values = {3,1,6,2,9,0,7,4,5,8};
        int temp = 0;
        for (int i =0;i<values.length-1;i++){
            boolean flag = true;
            for (int j = 0;j<values.length-1-i;j++){
                //比较大小换顺序
                if (values[j] > values[j+1]) {
                    temp = values[j];
                    values[j] = values[j+1];
                    values[j+1] = temp;
                    flag = false;
                }
                System.out.println(Arrays.toString(values));
            }
            if (flag){
                System.out.println("结束！！！！！！！！");
                break;
            }
            System.out.println("######################");
        }
    }
}

二分法查找_折半检索。

测试二分法折半查找（折半检索）
示例代码：

 public class TestBinarySearch {
    public static void main(String[] args) {
        int[] arr = {30,20,50,10,80,9,7,12,100,40,8};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(myBinarySearch(arr,400));
    }
    public static int myBinarySearch(int[] arr,int value) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (value == arr[mid]) {
                return mid;
            }
            if (value>arr[mid]){
                low = mid+1;
            }
            if (value<arr[mid]){
                high = mid -1;
            }
        }
        return -1;
    }
}