java语法

流程控制

Scanner对象

用来获取用户的输入

Scanner s = new Scanner(System.in);

String str = s.nextLine(System.in);

获取字符串：nex（）、nextLine（）

判断是否还有输入的数据：hasNext（）、hasNestLine（） 一般在读取数据前判断

用完之后要关掉：s.close();

增强For循环

循环数组和集合

for (声明语句：表达式){

int[] numbers = {10,20,30,42};
for(int x:numvers){
    System.out.println(x);
}

方法

public static void Hello(){
    System.out.prinln("Hello World!");
}

public 公共的

static 静态方法：独立该类的任何对象，不依赖类特定的实例，被类的所有实例共享

• 能直接调用，不是static方法则需要实例化才能调用
• static方法不能调用非static方法 （static方法与类同时加载，非static方法在类实例化之后才加载）
• void 返回值

• 值传递：复制实参的值给形参
• 引用传递：对于对象，可以改变对象的属性，本质还是值传递

方法的重载

方法名相同，但形参不同

• 方法名相同
• 参数列表不同
• 返回类型可以相同可以不同
• 仅仅返回类型不同不足以成为方法的重载

方法名相同时，编译器根据调用方法的参数个数、类型等去匹配对应的方法

命令行传参

cmd：java文件路径下编译文件 -> 退回到src文件下运行（eg：java com.method.Demo01）并传参

可变参数

在方法声明中，在指定参数后加省略号

一个方法只能指定一个可变参数且必须时方法的最后一个参数

public static int add(int... num){
    
}

数组

创建：dateType[] arrayRefVar = new dateType[arraySize];

Arrays类

面向对象

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

一个类中只能有一个public

创建对象

使用new关键字创建对象

public class Student{
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"在学习")；
    }
}

public class Application{
    public static void main(String[] args){
        Student lihua = new Student;
        System.out.println(lihua.name);
        lihua.study();
    }
}

类的构造器（构造方法）

• 实例化时会自动隐式定义，也可显示定义
  • 必须与类的名称相同
  • 没有返回类型（不是void）
• 能实例化初始值
• 定义了有参构造，无参构造就必须显示定义（尽量把无参构造显化）

封装

高内聚，低耦合

数据的隐藏

• 属性私有：private关键字

private int name;

• get/set方法：可以操作私有属性

public String getName{
    return this.name;
}
public void setName(String name){
    this.name = name;
}

继承

对一批类的抽象

拓展：extends

public class Person{
    
}

public class Student extends Person(){
    
}

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

java中所有的类都默认继承Object类

• this关键字：引用当前对象
• super关键字：引用父类对象

构造器

子类构造器默认调用父类构造器

调用构造器必须是构造函数主体的第一条语句（this()、super()）

public class Person{
    
}
public class Student extends Person(){
    public Student(){
        //super();默认调用父类构造器
    }
}

方法的重写

重写（Override）都是方法的重写，与属性无关

public class B(){
    public static void text{
        System.out.println("B->text()");
    }
}

public class A extends B{
    public static void text(){
        System.out.println("A->text()");
    }
}

public class A extends B{
    public static void main(String[] args){
        A a = new A();
        a.text();/*静态方法：A->text()
        		   非静态方法：A->text()
        		  */
        
        B b = new A();//父类的引用指向了子类
        b.text();/*静态方法：B->text()
        		   非静态方法：A->text()
        		  */
    }
}

• 静态方法：方法调用只和定义的数据类型有关
• 非静态方法：重写了父类的方法，调用时使用的是重写了之后的方法（需要用public）
• 修饰符：public > protected > default(默认) > private（范围可以扩大但不能缩小）

多态

同一方法可以根据发送对象的不同而采用不同的行为方式

一个对象的实际类型是确定的，指向的引用类型不确定

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

• 对象能执行的方法主要看定义的类型

• 多态存在的必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象

• 关键字instanceof：a instanceof b判断两个对象之间是否存在父子关系（a（a的实际类型）是否是b的子类）

static

类加载时static方法就加载

public class Demo{
    static{}//静态代码块，最先加载，只执行一次
    {}//匿名代码块，其次加载，可以用来赋初值
    public Demo(){}//构造器，最后加载
}

• 静态导入包:可以直接使用方法

import static java.lang.Math.random;

抽象类

• 关键字：abstract

不能new抽象类

抽象类里可以写普通方法

抽象方法必须在抽象类中

//抽象类
public abstract class Action{
    //约束，抽象方法
    public abstract void doSomething();
}

继承了抽象类的子类必须实现抽象类的方法，除非子类也是抽象类

抽象类也存在构造器

接口

只有规范，不能写方法，实现约束和实现分离：面向接口编程

• 关键字：interface

public interface UserService{
    //接口中的所有定义都是抽象的：public abstract（方法）、public static final（属性）
    void add();
}

public interface TimeService{
    void time();
}

• 接口都需要有实现类

接口可以多继承

//命名规则:接口名加Impl，用关键字implements实现
public UserServiceImpl implements UserService,TimeService{
    public void add(){
        
    }
    public void time(){
        
    }
}

内部类

成员内部类，静态内部类

public class Outer{
    private int id;
    public void out(){
        System.out.println("外部")；
    }
    public class Inner{
        public void in(){
            System.out.println("内部")；
        }
        //能获得外部类的私有属性，加static之后（静态内部类）则不能获得
        public void getID(){
            System.out.println(id)；
        }
    }
}
//实例化
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

public class Demo01{
    
}
//一个类文件中只能有一个public类
class Demo02{
    
}

局部内部类

public class Demo01{
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

匿名内部类

public class Demo01{
    public void run(){
        
    }
}

new.Demo01().run();//没有名字

异常

把异常当做对象处理，并定义一个基类java.lang.Throwable作为所有异常的超类

• 关键字：try、catch、finally、throw、throws

public class Demo01{
    public static void main(String[] args) {
        int a=1;
        int b=0;

        try{//try监控异常
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch(捕获的异常类型)捕获异常,可以写多个，捕获多个异常
            System.out.println("0");
        }finally{//善后，可以不使用，一般用于释放资源
            System.out.println("finally");
        }
    }
    public void add(int a,int b) throws ArithmeticException{//方法上抛出异常
        if(b==0){
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
    }

}

自定义异常：自定义异常类并继承Exception类