javaSE学习笔记

javaSE学习

• 异常总结

  • 数组

    ArrayIndexOutOfBoundsException//数组越界异常
    

  • 多态

    ClassCastException//类型转换异常
    

• 数组

  //1.数组定义
  int[] nums;//声明数组变量
  nums = new int[5];//创建数组
  int[] nums = new int[5];// 声明和创建数组可以一起
  for(int i =0; i < nums.length; i++) nums[i] = i + 1;//为数组元素赋值
   
  //静态初始化： 创建 + 赋值
  int[] a = {1,2,3};
  //动态初始化：包含默认初始化
  int[] b = new int[10];//int类属性默认初始化为0
  
  //Arrays类
  Arrays.toString(a);//打印数组
  Arrays.sort(a);//数组排序
  Arrays.fill(a,0);//数组填充
  
  //稀疏数组
  //把多维数组中特殊值的信息记录下来即可
  //如保存二维数组,使用一个较小的二维数组a[i][3]
  //a[i][0]表示行 a[i][1]表示列 a[i][2]表示数值
  
  

• 面向对象OOP

  • 属性

    //属性的默认初始化
    //数学： 0  0.0
    //char: u0000
    //boolean: false
    //引用： null
    

  • 创建对象

    Student Xiaoming = new Student();
    //构造器（定义构造方法）
    Student(){}//无参构造
    Student(String name){ //有参构造
        this.name = name;
    }
    //alt+insert快捷键 创建构造器
    

  • 封装

    //设置private属性
    private String name;
    
    //设置get与set方法访问私有字段
    public void setName(String name){
        //可以在set方法检测数据的合法性
        //if(条件限制)
        this.name = name;
    }
    public String getName(){
    	return this.name;
    }
    
    
    // 匿名代码块 静态代码块
    //静态代码块在类加载时执行
    //匿名代码块在类创建（实例化时执行）
    

  • 继承

    //Java中类只有单继承，没有多继承
    public class Person{}
    class Student extends Person{}
    //Ctrl+H可以查看继承关系
    //Java中所有类，都默认直接或间接继承Object类
    
    //修饰符
    //private protected public
    
    //super
    //1.super调用父类的构造方法，必须在构造方法的第一个
    //2.super必须只能出现在子类的方法或者构造方法中
    //3.super和this不能用同时调用构造方法
    
    //super VS this
    /*
    	1.代表的对象不同：
    		this 代表本身调用者这个对象
    		super 代表父类对象的引用
    	2.前提：
    		this 没有继承的情况下也能使用
    		super 只有在继承条件下才能使用
    	3.构造方法
    		this(); 本类的构造
    		super(); 父类的构造
    */
    
    /*方法重写：需要有继承关系，子类重写父类方法
    	1.方法名必须相同
    	2.参数列表必须相同
    	3.修饰符：范围可以扩大但不能缩小： 			public>Protected>Default>private
    	4.抛出的异常：范围可以被缩小，但不能被扩大
    	
    	快捷键：Alt + Insert => override
    */
    

  • 多态

    /*
    多态注意事项：
    	1.多态是方法的多态，属性没有多态
    	2.父类和子类有联系 （无联系会有类型转换异常）
    	3.存在条件：继承关系。方法需要重写，父类引用指向子类对象 eg. Father f1 = new Son();
    	
    	PS.不存在多态的方法：
    		1.static方法（属于类，不属于实例）
    		2.final变量修饰（无法改变无法重载）
    		3.private方法（无法被子类继承）
    */
    
    //instanceof
    //X instanceof Y 判断X变量实际指向的对象是否为Y的子类
    
    
    /*
    类之间的类型转换
    	1.父类的引用指向子类的对象（条件）
    	2.把子类转换为父类=>向上转型（会导致无法使用子类的特有方法）
    	3.把父类转换成子类=>向下转型（需要进行强制转换）
    */
    
    Student s1 = new Student();
    Person obj = new Student();//向上转型
    Person person = s1;//向上转型（无需强转）
    
    Student s2 = (Student) obj;//向下转型
    //需要用obj变量调用子类方法需要向下转型
    ((Student) obj).run();
    
    //如果
    Person p1 = new Person();
    Student s3 = (Student) p1;
    //编译无措但运行时将报错（ClassCastException）
    

  • 抽象类

    //使用abstract修饰符
    //抽象类的所有方法，继承了它的子类，都必须要实现它的方法
    
    /*
    抽象类的性质
    	1.抽象类无法实例化对象
    	2.抽象方法必须在抽象类中
    	3.抽象类中可以写普通方法
    */
    

  • 接口

    //接口声明的关键字interface，接口都需要有实现类
    
    //接口中的所有定义的方法其实都是抽象的 public abstract
    
    //接口中所有定义的属性都是public static final
    
    //接口可以多继承
    //implements可以实现多个接口
    
    //接口不能被实例化，接口中没有构造方法
    public interface UserService {}
    public class UserServiceImpl implements UserService {} 
    //实现了接口的类，就需要重写接口中的方法
    
    
    

  • 内部类

    //成员内部类 可以获得外部类的私有属性
    //静态内部类 同个java文件中的class xxx{}
    //局部内部类
    //匿名内部类 不用把实例保存在变量中
    
    

• 异常

  /*
  异常分类
  	1.检查性异常
  	2.运行时异常
  	3.错误Error
  */
  
  //java把异常当作对象处理（java.lang.Throwable）
  
  /*
  Error与Exception区别
  	1.Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，JVM一般会选择终止线程
  	
  	2.Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常
  */
  

  /*
  异常处理五个关键字
  try catch finally throw throws
  */
  
  //假设要捕获多个异常：需要从小到大
  
  //Ctrl + Alt + T 快捷键异常处理
  
  try{ //try监控区域
      if(b==0){ 
       //throw 主动在方法内抛出 
       //throws 主动在方法上抛出
          throw new exception(); //主动抛出异常（一般在方法中使用）
      }
  }catch(){ //catch(想要捕获的异常类型) 捕获异常
       
  }catch(exception e){ 
      e.printStackTrace();//打印错误的栈信息
  }
  finally{ //处理善后工作
      
  }
  //可以不用finally