java基础（数组、面向抽象编程、static、异常）

数组

• 相同的数据类型的数据集合
• 按照一定的先后次序排列组合
• 通过下标来访问他们

声明---创建

• 建议 String[] a;
• String a [];//c 和c++才有不专业

String [] a =new int [10];
a[i]--取值

数组的默认初始化

• 数组是引用类型，他的元素相当于类的实例变量，因此数组一经过分配空间，其中的每个元素也按照实例变量同样的方式被隐藏初始化
• 静态初始化：：栈
• 动态初始化：：栈和堆

基本特点：

• 数组的长度是确定的
• 元素必须是相同的类型
• 数组的元素可以是任何的数据类型
• 数组变量属于引用类型
• 数组本身是对象，java的对象是在堆中的，数组对象是在堆中的
• 下标的合法区间[0,n-1]
• 数组也是对象，数组的元素属于成员变量
• 数组的长度是确定的，不可变，不能越界

数组的使用：

int[] a ={1,2,3,4,5};
//打印全部的数组元素
for（int i-0;i<a.length;i++){
    syso.(a[i]);
}
//计算所有元素的和
int sun=0;
for（int i-0;i<a.length;i++){
    //sum=sun+a[i]
    sun+=a[i];
}
//查找最大值
int max=arry[0];
for（int i-1;i<a.length;i++){
    if(array[i]>max){
        max=array[i];
    }
}
//增强的for循环  但是取不到下标
for(int array :a){
    syso(a);
}
//反转数组
int[] result new int[a.length];
for（int i-1;j<result.length;i<a.length;i++;j--){
 	result[j]=a[i];
}

多维数组：

int[][] a={{1,2,3},{1,2,3},{1,2,3}};

遍历
for(int i=0;i<a.length;i++){
    for(int j=0;j<a[i].length;j++){
        syso.(a[i[j]]);
    }
}

对象Arrays

java.util.arrays

int[] a ={1,2,3,4,5};

static修饰可以直接用

• 打印数组的元素

Arrays.toString(a);

• 排序

Arrays.sort(a);//升序

• 赋值

fill方法
Arrays.fill(a,0);

• 比较

比较equals方法  //比较数组的元素是否相等

• 查找

binarySearch能对排序好的查找进行二分查找

稀疏数组

• 记录数组一共有几行几列，有多少个不同值
• 把具有不同值的元素和行列及值记录在一个小的规模的数组中，从而缩小小程序的规模

int[][] array =new int[11][11];
array[1][5]=10;
array[5][5]=5;
//获得有效值的个数
int sum =0;
for(int i=0;i<array.length;i++){
    for(int j=0;j<array[i].length;i++){
        if(array[i][j]!=0){
            sum++;
        }
    }
}
//创建稀疏数组
int [][]array2 =new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍历二位数组，将非零的值存放在数组中
int count =0;
for(int i=0;i<array.length;i++){
    fro(int j =0;j<array[i].length;j++){
        if(array[i][j]!=0){
            count++;
            array2[count][0]=i;
            array2[count][1]=j;
            array2[count][2]=array[i][j];
        }
    }
}

八种排序算法

• 冒泡排序 O(n2)

for(int i=0;i<array.length-1;i++){
    for(int j=0;j<array.length-i;j++){
        if(array[j+1]>array[j]){
            temp=array[j];
            array[j]=array[j+1];
            array[j+1]=temp;
        }
    }
}

• 选择排序

for(int i =0;i<arr.length-1;i++){
    for(int j=i+1;j<arr.length;j++){
        if(arr[i]>arr[j]){
            int tem = arr[i];
            arr[i]=arr[j];
            arr[j]=tem;
        }
    }
}

• 二分查找(前提是拍好序列)

内存分析

堆

• new的对象
• 数组
• 可以被所有的线程所共享的，不会存放别的对象的引用

栈

• 存放基本的变量类型
• 引用的对象的变量

方法区

• 可以被所有的线程共享
• 包含了所有的clss和static变量

面向对象编程

oop

对于描述复杂的事物，为了从宏观上把握，从整体上合理的分析，我们需要使用面向对象的思想来分析整个系统。但是在微观操作上，仍然需要面向过程的思想去处理

本质：已类的方式组织代码，已对象的组织（封装数据）

特征：

• 封装
• 继承
• 多态

方法的调用、值传递、类和对象的关系

类是一种抽象的数据类型，但是不能表示一种具体的事物

对象是抽象的概念的具体实例

new 创建对象

类：

• 属性
• 方法

抽象的类要实例化

构造方法：

• 必须和类的名字相同
• 必须没有返回值

new的内存分析：

。。。。

封装：

• 属性私有，get/set

高内聚，低耦合

继承

java类中只有单继承，没有多继承

extends

• 继承是类和类之间的关系，类之间的关系好友依赖，组合，聚合
• 继承是两个类的关系 源生类 派生类
• 子类和父类之间有is a关系
• Object
• super
• 方法的重写

Super方法

super.父类的方法直接写就行了

this当前类的

调用构造器只能在第一行

默认调用父类的构造器

如果父类没有无参的构造，子类也无法写无参的构造

子类的代码会隐藏父类的无参的构造

注意：

• super调用父类的构造方法，必须在构造方法的第一个
• super必需只能出现在子类的方法或者构造方法中
• super和this不能同时使用

前提：

• this本身调用者这个对象
• super：代表父类对象的应用

构造方法：

• this（）本身的构造
• super父类的构造

重写@Override

• 非静态的
• 私有的不行
• 方法名必须相同
• 参数列表相同
• 修饰符可以扩大
• 重写可能会抛出异常，异常可以缩小不能扩大

public》protected》Default》private

多态

动态编译

interface implements

存在的条件：

• 有继承关系
• 子类重写父类的方法
• 父类的引用指向子类对象

父类的应用指向子类

B b =new A（）；

class A extends B；

注意事项：

• 多态是方法的多态，属性没有多态
• 父类和子类，有联系 类型转换异常ClassCastException
• 存在条件。。。。。前面有

方法要被重写--多态：

不能重写的

• static属于类，不属于实例
• final 修饰的无法 在常量池内
• private修饰的

instanceof 判断一个数据的类型

x instanceof y;

x和y之间是否有父子关系

类型转换，子类的方法要类型转换。

子类----父类 ---向上转型

父类---子类------强制转换

Static

private static int a;//多线程
private int b;

静态变量在一个特别的区里面；

public static run(){

}
public go(){

}

• 静态方法只能静态方法
• 静态方法随着类加载生成
• 可以直接使用（静态代码块）

静态代码块static{}------匿名代码块{}-----构造方法

静态导入包

import static java.lang.PI;

被final定义的类不能被继承----断子绝孙

抽象类

abstract：

抽象类的子类要实现抽象类的所有的方法；

extends

但是是单继承

• 不能new抽象类，只能那子类去实现它：约束
• 抽象类里面可以放普通方法
• 抽象方法必须放在抽象类里面

接口

interface implements

• 只有规范，面向接口编程

接口的本质是契约

接口的方法都是public abstratact 的

• 类实现接口必学实现接口中的方法
• 接口里面的变量是常量public static final

接口不能实例化，没有构造方法

内部类

• 成员内部类
• 静态内部类
• 局部变量
• 匿名内部类

public Class outer{
    private int id;
    public void out(){
        syso（“外部类”）
    }
    //内部类可以获得外部类的私有属性和方法
    public class Inner{
        public void in(){
		syso("内部类")；
}
    }
}

//内部类
Outer out =new Outer（）；
Outer.Innter  inner= out.new Inner（）；

静态内部类：

public Class outer{
    private int id;
    public void out(){
        syso（“外部类”）
    }
    //内部类可以获得外部类的私有属性和方法
    public static class Inner{
        public void in(){
		syso("内部类")；
            //这里就拿不到外部类的变量的值了，静态内部类无法访问静态方法
}
    }
}

局部内部类：

在方法里面写内部类：

public Class outer{
    private int id;
    public void out(){
        syso（“外部类”）
            public class Inner{
        public void in(){
		syso("内部类")；
}
    }
    }
}

一个java里面可以写多个class类

class a{}
class b{}

匿名内部类：

接口 a = new 接口（）{
    @Override
    方法
}

Error和Exception

• 异常是指运行中出现不预期的各种状况
• 异常发生在程序运行期间，他影响了正常的执行流程

异常分为：

• 检查性异常
• 运行时异常
• 错误Error

java.lang.Throwable 超类

• ArrayLndexOutOfBoundsException 数组线标越界
• NullPointerExceotion空指针异常
• ArithmeticException算数异常
• MissingResourceException 丢失资源
• ClassNotFountException找不到类等异常

抛出异常：

捕获异常

关键字：

try catch finally throw throws

throw new ArithmeticException();//抛出一个异常
//一般在方法中使用，加入这个方法处理不了这个异常，就抛出异常
public void a throws ....

自定义异常

public ex extends Exception{
    //传递数字》10
    private int detail；
    public ex (int a){
        this.detail = a;
    }
    @Override
    public String toString（）{
	return "myex{"+detail+"}";
}
}

throw new ex();