抽象类与接口、内部类、String中常用方法

抽象

抽象方法：方法前面加有abstract修饰方法，抽象方法没有方法体，含有抽象方法的类是抽象类；

抽象方法特点：父类没有实现，子类必须实现，即子类必须重写父类的抽象方法。

抽象类的使用要点：

• 有抽象方法的类只能定义成抽象类；
• 抽象类不能实例化，即不能用new来实例化抽象类；
• 抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用；
• 抽象类只能用来被继承
• 抽象方法必须被子类实现

接口

接口：就是比"抽象类"还“抽象”的“抽象类”，可以更加规范的对子类进行约束。接口中的方法都是抽象方法。

声明格式：

[访问修饰符] interface 接口名 [extends 父接口1，父接口2]{
		常量定义；
		方法定义；
}

定义接口的详细说明：

1. 访问修饰符：只能是public或默认；
2. 接口名：和类名采用相同的命名机制；
3. extends：接口可以多继承；
4. 常量：接口中的属性只能是常量，总是：public static final修饰，即默认就有public static final修饰；
5. 方法：接口中的方法只能是：public abstract，省略的话也是public abstract。

要点：

1. 子类通过implements来实现接口中的规范；
2. 接口不能创建实例，但是可以用于声明引用变量类型；
3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

Java中的类只有单继承，没有多继承；

Java中的接口有单继承、多继承。

静态内部类与非静态内部类：

//非静态内部类
public class TestInnerClass{
    class Outer{
        private int age=10;
        public void testOuter(){
            
        }
        class Inner{
            
        }
    }
}

//静态内部类
public class TestInnerClass{
    class Outer{
        private int age=10;
        public void testOuter(){
            
        }
        static class Inner{
            
        }
    }
}

注意：

1. 非静态内部类必须寄存在一个外部类对象里；
2. 非静态内部类可以直接访问外部类的所有成员，但是外部类不能直接访问非静态内部类成员；
3. 非静态内部类不能有静态方法、静态属性和静态初始化块；
4. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

非静态内部类应用实例：

public  class Test {
    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();

        }
        class Inner{
            private String name;

            public void show(){
                age=100;
                System.out.println("外部类的成员变量age="+Outer.this.age);
            }
        }
    }

静态内部类的使用要点：

1. 当一个静态内部类对象存在时，并不一定存在对应的外部对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法；
2. 静态内部类看做外部类的一个静态成员。因此，外部类的方法中可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过new静态内部类()访问静态内部类的实例。

静态内部类对象的使用实例：

public  class Test {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer.Inner();   //定义一个静态内部类对象
        inner.show();  //调用静态内部类中的方法
    }
}
    class Outer{
        private int age=10;
        public void testOuter(){
            System.out.println("我是外部类");

        }
       static class Inner{
            private String name;
            public void show(){
                System.out.println("我是内部类");
            }
        }
    }

静态内部类和非静态内部类使用实例：

package com.ysh.review05;



/**
 * 静态内部类、非静态内部类、外部类访问范围
 */
public class Outter {
    static String name="Outter";
    int age=18;
    //非静态内部类可以访问外部类的静态成员和非静态成员
    //非静态内部类中不能有静态属性和静态方法
    class Inner{
        String name="Inner";
        String gender="man";
        public void testInner(){
            //就近原则  name="Inner"
            System.out.println(name);
            System.out.println(age);
        }
    }
    //静态内部类中不能访问外部类的非静态成员
    static class Inner02{
        static String id="2020";
        public void testInner02(){
            System.out.println(name);
            //不能访问非静态成员
            //System.out.println(age);
        }
    }
    public  void  test(){
        //不能直接访问内部类的属性，但可以通过对象.属性名访问内部类的属性
        System.out.println(new Outter().new Inner().gender);
        //不能直接访问内部类的静态属性，但可以通过类.属性名访问内部类的静态属性，
        System.out.println(new Outter.Inner02().id);
    }
    public static void main(String[] args) {
        new Outter().new Inner().testInner();
        new Outter.Inner02().testInner02();
        //通过对象.属性名访问内部类的属性，不能直接访问
        System.out.println(new Outter().new Inner().gender);

    }
}

String中相关方法 ：

charAt(a):提取小标为a的字符；

length()：字符串的长度；

s1.equal(s2)：比较两个字符串是否相等；

s1.equalsIgnoreCase(s2):比较两个字符串(忽略大小写)；

s1.indexOf(“java”):确认字符串s1中是否包含java，包含则返回Java第一次出现的索引位置，否则返回-1；

s1.replace(’ a’,‘b’):s1字符串中的a换为b，但是这里要注意的是：通过使用这个方法是产生一个新的字符串，而原来的字符串s1没有发生变化；

s1.startsWith(“How”):字符串s1是否以How开头；

s1.endWith(“you”):字符串s1是否以you结尾；

s1.substring(4):提取子字符串：从下标为4的开始到字符串结尾为止(包含下标为4的位置)；

s1.substring(4,7):提取子字符串：下标[4,7)不包括7；

s1.toLowerCase():将字符串s1全部转为小写；

s1.toUpperCase():将字符串s1全部转为大写；

s1.trim():去除字符串首尾的空格，但是中间的空格不能去除；

数组元素的拷贝：

System.arraycopy(src,srcPos,dest,destPos,length):

其中src表示源数组，srcPos表示从源数组哪个位置开始拷贝；dest表示目标数组，destPos表示将拷贝过来的元素从哪个位置开始存放，length表示拷贝元素的长度，即拷贝元素的个数。

removeElment(str,1)：将str数组中下标为一的元素删除，并且其后元素下标减一，例如：

String[] str={"阿里","腾讯","京东","百度","美团"}；
removeElment(str,1);
处理之后数组str中的内容是：{"阿里","京东","百度","美团"，null}

数组中的toString()方法：方便打印数组中的内容；

int[] a={10,20,39};
System.out.println(Arrays.toString(a));

输出结果：
	[10,20,39]

数组中的sort()方法：对数组进行排序，按照从小到大的顺序排序。

int[] a={90,20,39};
Arrays.sort(a);
System.out.println(Arrays.toString(a));

输出结果：
	[20,39,90]

binarySearch(a,30):查找数组中30所在位置的索引号；

int[] a={90,20,39};
System.out.println(Arrays.binarySearch(a,20));
//如果在数组中没有找到20所在的位置，则系统默认返回-1

输出结果:
	1

数组中的冒泡排序：

  /*  冒泡排序 */
        int a[]={3,4,1,9,10,8};
        int temp=0;
        for (int i=0;i<a.length;i++){
            //循环i次即找出最大值排名为i的元素，还有a.length-i个元素还未排好序
            for (int j=0;j<a.length-1-i;j++){
                //依次循环找出最大的，并且存放在末尾
                if (a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));

数组中的二分法查找（其数组必须是先排好序的）：

/**
*数组中的二分法查找
*/
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;
    }