2022-9-5 JavaSE note

Java SE

1、IDEA基本操作

 psvm + 回车 ： main() 方法声明
 sout + 回车 ： = System.out.println();
 Ctrl + D : 把当前行复制到下一行
 new Scanner + 回车 ： 调用Scanner方法
 new Scanner(System.in);    alt + 回车 + 回车  →   Scanner scanner = new Scanner(System.in);
Scanner + 回车 ： 调用Scanner方法

2、java零散笔记

• java 是值传递

• Scanner用完记得结束

Scanner scanner = new Scanner(System.in);
//内容
scanner.close();//结束使用Scanner

int[] numbers = {10,20,30,40,50}; //定义一个数组
//遍历数组的元素
for (int x : numbers){
    System.out.println(x);
}

• 关键字

//public    公共的
//protected 受保护的
//default   默认的，可以不写
//private   私有的

• 构造器

 /*
     	构造器：
            1. 和类名相同
            2. 没有返回值
        作用：
            1. new 本质在调用构造方法
            2. 初始化对象的值
        注意点：
            1.定义有参构造只后，如果想使用无参构造，必须显示的定义一个无参的构造

        Alt + Insert

        this. =
*/

• 面向对象

  5. 对象的创建和使用
      - 必须使用new 关键字创造对象，                       			构造器 Person  kuangshen = new Person();
     - 对象的属性  kuangshen.name
     - 对象的方法  kuangshen.sleep()
  

• 面向对象的三大特性

  • 封装

    private int id;
    public int getId() {
         return id;
     }
    
     public void setId(int id) {
         this.id = id;
     }
    //用到了private，要想调用，就要写 get/set 方法
    

  • 继承

      //extends关键字
      public class Teacher extends Person {
      }	//Teacher类继承Person类
      //在Java中，所有的类，都默认直接或者间接继承Object类
    

    • 重写

       //重写都是方法的重写，与属性无关
      
       //静态方法 ： //方法的调用只和左边，定义的数据类型有关
       A a = new A();
       a.test();//A
       //父类的引用指向了子类
       B b = new A();  //子类重写了父类的方法
       b.test();//B
      
      /*
      	重写：需要有继承关系，子类重写父类的方法！
      		1.方法名必须相同
      		2.参数列表必须相同
      		3.修饰符：范围可以扩大但不能缩小：public > 				protected > default > private
      	重写，子类的方法和父类必须要一致，方法体不同！
      	alt + insert : override?
      */
      

    • super

      /*
      	1.调用子类的构造方法时，会默认调用父类的无参构造方法，		要想调用父类的有参构造，
           	我们需要显示的：super(参数列表)，来调用父类有参数		的构造函数，在子类的构造方法中第一行加入super();
      */
      
      //super调用父类的构造方法，必须在构造方法的第一个
      //super必须只能出现在子类的方法中或者构造方法中
      //super 和 this 不能同时调用构造方法！
      
      /*
      	Vs this :
      		代表的对象不同:
      		this：本身调用者这个对象
      		super：代表父类对象的引用
      	前提
      		this：没有继承也可以使用
      		super：只能在继承条件才可以使用
      	构造方法
      		this(); 本类的构造
      		super();父类的构造
      */
      

    • object类

      //在Java中，所有的类，都默认直接或者间接继承Object类
      

  • 多态

    /*
    	1.多态是方法的多态，属性没有多态
    	2.父类和子类，有联系
    	3.存在的条件：继承关系，方法需要重写，父类引用指向子类对象 			Father f1 = new Son();
    
    		不能被重写的方法：
    			1.static 方法，属于类，它不属于实例
    			2.final 常量
    			3.private 方法 私有的
    */
    
    //instanceof 判断两个类有没有父子关系
    
    /*
    	  //类型之间的转换：
    
            //高                   低
            Person obj = new Student();
    
            //student 将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
            ((Student) obj).go();
    
            //子类转化为父类，可能丢失自己的本来的一些方法！
            Student student = new Student();
    		Person person = student;   			//低转高，直接转
    
    		1.父类引用指向子类的对象
    		2.把子类转换为父类，向上转换；
    		3.把父类转换为子类，向下转换；强制转换
    		4.方便方法的调用，减少重复的代码！简介
    */
    

• static

  1.非静态方法可以调用静态方法中的所有东西,静态方法可以调用静态方法，不能调用非静态方法中的东西
      类可以直接调用静态的变量：Student.age
  2.执行顺序：静态代码块(只执行一次) > 匿名代码快 > 构造方法
  3.被final修饰的类，不能被继承，没有子类 (final之后断子绝孙)
  

• 抽象类

  //抽象类的所有方法，继承了它的子类，都必须要实现它的方法~  除非子类也是抽象类，就不用了，
  
  //abstract ， 抽象方法，只有方法名字，没有方法的实现！
      public abstract void doSomething();
  
      //1. 不能new这个抽象类，只能靠子类去实现它；约束！
      //2. 抽象类中可以写普通的方法~
      //3. 抽象方法必须在抽象类中~
      //抽象的抽象：约束
  

• 接口

  //interface 定义的关键字 ， 接口都需要有实现类
  
  //接口中的所有定义的方法其实都是抽象的 public abstract
  
  // 抽象类：extends
  // 类 可以实现接口 implements 接口
  // 实现了接口的类，就需要重写接口中的方法
  
  //多继承~利用接口实现多继承
  

• 内部类

  • 成员内部类

    1. 调用成员内部类

       //在外面的类的最后，写一个方法，调用成员内部类(创建对象，在访问)
       class Outer08{
           class Inner08{ //成员内部类
               public void say(){
       
               }
           }
       
           public void t1(){
               Inner08 inner08 = new Inner08();
               inner08.say();
           }
       }
       

    2. 可以直接访问外部类的所有成员，包含私有的。

    3. 外部其他类调用内部类的二种方法

       //
       Outero8.Inner08 inner08 = outero8.new Inner08();
       inner08.say();
       //2. 在外部类中，编写一个方法，可以返回 Inner08 对象
       //方法，返回一个Inner08实例
       public Inner08 getInner08Instance(){
           return new Inner08();
       }
       //调用
       Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
       inner08Instance.say();
       

    4. 如果成员内部类的成员和外部类的成员重名，会遵守就近原则，可以通过 外部类.this.属性 来访问。

  • 静态内部类

  • 局部内部类

    1. 可以直接访问外部类的所有成员，包含私有的

    2. 不能添加访问修饰符，但是可以使用 final 修饰

    3. 作用域：仅仅在定义它的方法或代码块中

    4. 外部类在方法中，可以创建 Inner02 对象，然后调用方法即可

       class Outer02{//外部类
           public void m1(){//方法
               final class Inner02{//局部内部类（本质仍然是一个类）
                   public void f1(){
       
                   }
               }
               Inner02 inner02 = new Inner02();
       		inner02.fi();
           }
       }
       
       //main 方法中调用
       Outer02 outer02 = new Outer02();
       outer02.m1();	//调用了fi() 方法
       

    5. （在类的方法中的类，调用的时候可以在此方法最后 new 局部内部类）

    6. 如果外部类和局部内部类的成员重名，默认遵循就近原则，可以通过 外部类.this.成员 来访问。

  • 匿名内部类

    1. 没有名字初始化类，不用将实例保存到变量中

  //一个Java类中可以有多个class类，但是只能有一个public class
  

• 异常

  //假设要捕获多个异常：从小到大