Day03 学习java 2020-09-30

学习Java Day03

数组

1. 数组创建的三种方式：
   • 静态初始化 int[] a = {1,2,3,4}
   • 动态初始化 int[] a = new int[6];
   • 两种方式的结合 int[] a = new int[]{1,2,3,4}
2. 数组创建后会进行默认初始化
3. 数组只能进行同一种类型的数据的存储，而且 创建时需要指定个数
4. 操作数组有一个工具类Arrays

数组遍历的2种方式

//1. 普通for循环 可以根据下标对数组元素进行修改
int[] arrray = {1,3,5,7,9,2,4,6,8,10};
for(int 1=0;i<array.length;i++){
	System.out.println(array[i]);
}
//2.加强for循环 只是进行循环遍历
for(int num:array){
	System.out.println(num);
}

常见的冒泡排序

int[] array = {1,3,5,7,9,2,4,6,8,10};
int temp=0;
for(int i=0;i<array.length-1;i++){  // 定义循环的次数
	for(int j=0;j<array.length-i-1;j++){ // 每次循环结束最后面的都是最大的 所以 j<array.length-i-1
		if(array[j]>array[j+1]){
			temp=array[j+1];
			array[j+1]=array[j];
			array[j]=temp;
		}
	}	
}
System.out.println(Arrays.toString(array));

多维数组本质还是一个数组，二维数组为例

int[][] array = {{1,2,3},{7,8,9}};
// 本质还是一个数组，就是将原本一维数组的元素替换成一个数组

类

• 类是一种抽象的数据类型，是对某一事物的整体描述，而对象是抽象概念的具体实例
• 一个类默认会有一个默认的无参构造器，在通过new创建对象时，其实在调用调用这个无参构造器
• 但是如果自己定义了一个有参构造器，则不会再生出无参构造器，需要自己手动定义
• 在定义类时，最好对类中的属性进行私有化定义(private),然后定义get,set方法进行对这个私有化属性的修改，实现封装的效果
• java中可以有继承，即通过extends可以实现子类对父类的继承，私有方法（private修饰的方法）不会被继承
• 继承时子类可以对父类中的方法进行重写，在进行方法重写时，子类的修饰符（public>protected>default>private）级别必须大于父类的，抛出异常需要小于父类的异常范围
• 重写的父类方法不包括 static修饰的静态方法（子类可以定义同名的static方法，但是会把父类的static方法进行隐藏），private修饰的（私有的不能被继承），final修饰的（不能被修改）
• 如果父类没有无参构造方法，子类的构造方法需要通过super(参数)，来显示的调用父类的构造方法，而且必须是子类构造方法的第一行
• 类除了封装，继承，还有一个重要的特性多态性，就是父类的引用指向子类的对象,但是这个对象（如下obj）只能调用Father类的方法，如果Son类对父类的方法进行重写，则会调用子类的方法

class Father(){...}
class Son extends Father(){...}
...
	Father obj = new Son();

• 类的类型判断有instanceof关键字， 使用方式 X instanceof Y ， 返回结果Boolean值
  解释为 对象 X 是否是 类Y及其子类的对象 所以 x instanceof Object 永远是对的，因为在java中所有的类都继承Object类
• java 中还有匿名代码块，静态代码块，其中静态代码块，在加载类的时候执行，只会执行一次，而匿名代码块在每次通过new创建对象的时候执行

public class m{
	{//匿名代码块}
	static{//静态代码块}
}

• static 在修饰类的成员变量时，该变量就成为了类变量，可通过类.变量名直接调用，而且每个创建的对象共享这个变量

抽象类

• 通过abstract修饰的类是抽象类，通过abstract修饰的方法是抽象方法
• 抽象类可以没有抽象方法，但是有抽象方法的类必须要是抽象类
• 抽象类中可以定义普通方法，构造方法等
• 抽象类不能通过new来创建对象，需要通过子类重写这些方法，再通过new创建对象
• 但是Java是单继承的，不能多继承，所以抽象类使用起来较为局限，所以有了接口，能多实现

接口

• java的接口只能定义常量或者抽象方法

public interface Ic{
	double PI=3.14 // 省略了 public static final
	void show(String name); //省略了 public abstract
}

• 接口可以多实现 使用关键字 implements
• 接口不能定义构造方法，也不能实例化（new）
• 在类中实现接口必须实现接口的所有抽象方法

内部类

1. 成员内部类：在类内定义类

public class Outer{
	private int num = 12;
	public class Inner{   //可以使用全部的修饰符
   		int num = 24;
   		public void show(){
   			System.out.println(num) // 24
   			System.out.println(Outer.this.num)//12    使用与内部类同名的外部类变量 
   		}
   	}
}
// 调用内部类中的show方法
Outer.Inner obj= new Outer().new Inner();
obj.show();

2. 局部内部类：在类中的方法内定义类 只能用default，即没有修饰符

public class Outer{
    int num = 12;
    public void show(){
        int num=20;
        //num++; 
        class Inner{  // 只能这样定义，不能使用别的修饰符
        // 内部类如果访问所在方法的局部变量，必须是不可变或者只赋值一次
            public void tt(){
                System.out.println(Outer.this.num);  //12
                System.out.println(num); //20
            }
        }
        new Inner().tt();
    }
}

3. 匿名内部类：省略对象名

异常

1. java中的异常都继承自一个基类Throwable
2. 异常分为Error和Exception，
3. Exception又分为两种，一种继承自它的子类RuntimeException，成为运行时异常，可以不处理，编译时不会报错，执行时在报错，其余的都是编译期异常，需要对异常进行处理，才能正常书写
4. 对异常的处理的两种方式：
   • 通过try{}catch(){}finally{} 进行捕获处理
   • 通过在方法上定义throws继续向上抛出，直到在某处进行处理
5. 还可以通过关键字throw进行自己手动抛出异常
6. 还可以自定义异常，定义一个类继承自Exception或者RuntimeException,这两种对异常的处理时机不同

try{
	int num=1/0; // 可能出现异常的代码块
}catch(xxxException e){
	// 出现该异常的逻辑操作，  可以定义多个catch 对不同的异常进行不同的处理，捕获异常的范围变大
}catch(yyyException e){
}catch(Exception e){
}finally{
	//这里的代码无论是否出现异常都会执行
}

public xxxException extends Exception{
	// 定义一个数字太小的异常
	public xxxException(){super();}
    public xxxException(String msg){super(msg);}
}
	public class TestException {
	    public static void main(String[] args) {
	        int n = 12;
	        try{
	            if(n<100){
	            	//throw new xxxException();
	                throw new xxxException("数字太小，请大于100.");
	            }
	        }catch (Exception e){
	            System.out.println(e);
	           // e.printStackTrace();
	        }finally {
	            System.out.println("finally");
	        }
	    }
	}
}