java第七次学习总结

[1] 抽象类（有方法/抽象方法）
（1）有抽象方法的类只能定义成抽象类
（2）抽象类不能实例化，即不能用new来实例化抽象类
（3）抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用
（4）抽象类只能用来被继承
（5）抽象方法必须被子类实现

public abstract class Animal{
	abstract public int shout（）；
	public void run(){
	System.out.println(“running”);
}
}
public Dog extends Animal {
	public void shout(){
}
}

[2]接口
比抽象还抽象
（1） 多继承
（2） 不能定义变量，只能定义常量

Public interface MyInterface{
	(public static final)int Age=100;
	(public abstract)void test():
}

[3] 内部类
在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。
a) 非静态内部类(外部类里使用非静态内部类和平时使用其他类没什么不同)
i. 非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
ii. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
iii. 非静态内部类不能有静态方法、静态属性和静态初始化块。
iv. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

class Outer {
    private int age = 10;
    class Inner {
        int age = 20;
        public void show() {
            int age = 30;
            System.out.println("内部类方法里的局部变量age:" + age);// 30
            System.out.println("内部类的成员变量age:" + this.age);// 20
            System.out.println("外部类的成员变量age:" + Outer.this.age);// 10
        }
    }
}

v. 内部类的访问：
外部类中定义内部类：
new Inner()
外部类以外的地方使用非静态内部类：

Outer.Inner  varname = new Outer().new Inner()
 public class TestInnerClass {
    public static void main(String[] args) {
        //先创建外部类实例，然后使用该外部类实例创建内部类实例
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
        Outer outer = new Outer();
        Outer.Inner inn = outer.new Inner();
        inn.show();
    }
}

b) 静态内部类
i. 定义方式：

static  class   ClassName {
//类体
}

ii. 使用要点：

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

class Outer{
    //相当于外部类的一个静态成员
    static class Inner{
    }
}
public class TestStaticInnerClass {
    public static void main(String[] args) {
        //通过 new 外部类名.内部类名() 来创建内部类对象
        Outer.Inner inner =new Outer.Inner();
    }
}
c）匿名内部类
适合那种只需要使用一次的类。比如：键盘监听操作等等。
语法：
new  父类构造器(实参类表) \实现接口 () {
           //匿名内部类类体！
}
匿名内部类的使用
this.addWindowListener(new WindowAdapter(){
        @Override
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    }
);
this.addKeyListener(new KeyAdapter(){
        @Override
        public void keyPressed(KeyEvent e) {
            myTank.keyPressed(e);
        }      
        @Override
        public void keyReleased(KeyEvent e) {
            myTank.keyReleased(e);
        }
    }
);

注意：匿名类无访问修饰符
[4]数组的一些方法
数组拷贝：
System.arraycopy(src,srcPos,dest,destPos,length);
src是被拷贝数组，srcPos是int型的数字表示从src数组哪里开始被拷贝，dest是拷贝的数组，destPos是int型的数字表示从dest数组哪里开始拷贝，length是拷贝的数量
数组删除：
核心思想是利用数值拷贝吧要删除的数据覆盖掉
数组扩容：
核心思想是定义一个新的更大的数组，然后把旧数组中的元素拷贝过来
数组内容打印：
Arrays.toString(a);//打印格式[10,20,30]
数组大小排序：
Arrays.sort(a);//用于将数组从小到大排序
数组的二分查找：
Arrays.binarySearch(a,12);//二分查找前要先排序
[5] 数组存储
int[] a=new int [3];
二维数组：

int [][] a=new int [3][];
a[0]=new int []{20,30};
a[1]=new int []{10,25};

[6] 冒泡排序的优化
在第一重循环下加 boolean f=true；
在产生交换的条件语句中的末尾加f=flase；
在第二重循环下加if（f=true）break；

[7]二分查找的核心
（1）low=0；high=arrays.length-1;mid=（low+high）/2；
（2）存在查找数据时返回位置

if（value==arrays[mid]）return arrays[mid];
value>low low=mid+1;
value<high high=mid-1;

（3）不存在要查找的数据时返回-1
[8]包装类的用途
对于包装类来说，这些类的用途主要包含两种：
（1） 作为和基本数据类型对应的类型存在，方便涉及到对象的操作，如Object[]、集合等的操作。
（2） 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法(这些操作方法的作用是在基本数据类型、包装类对象、字符串之间提供相互之间的转化!)。

public class Test {
    /** 测试Integer的用法，其他包装类与Integer类似 */
    void testInteger() {
        // 基本类型转化成Integer对象
        Integer int1 = new Integer(10);
        Integer int2 = Integer.valueOf(20); // 官方推荐这种写法
        // Integer对象转化成int
        int a = int1.intValue();
        // 字符串转化成Integer对象
        Integer int3 = Integer.parseInt("334");
        Integer int4 = new Integer("999");
        // Integer对象转化成字符串
        String str1 = int3.toString();
        // 一些常见int类型相关的常量
        System.out.println("int能表示的最大整数：" + Integer.MAX_VALUE); 
    }
    public static void main(String[] args) {
        Test test  = new Test();
        test.testInteger();
    }
}