JAVASE

Java IDEA快捷键

psvm自动生成

sout=System.out.println

查找：IDEA 优化

Ctrl+D：复制当前行到下一行

100.for：for(int i=0;i<100;i++);

JAVA基础语法

1.注释

1. 单行注释 //
2. 多行注释 /* */
3. 文档注释 /** */

2.关键字

3.数据类型

1.基本类型

整数（byte 1字节、short 2字节、int 4字节、long 8节字）

浮点（float 4字节、double 8字节）

字符类型（char 2字节）

布尔类型 boolean

2.引用类型

类

接口

数组

3.类型转换

高–低 强制转换

低–高 自动转换

4.作用域

类变量 、实例对象均在类的方法外，方法中若使用变量的话类变量在方法中直接可以使用，而实例对象得new一个对象。

类变量：static int salary =100；

4.文档DOC

参数信息：

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

代码书写

1.Scanner

格式：

Scanner scanner=new Scanner(System.in);

int i=scanner.hasNextInt();

Scanner scanner=new Scanner(System.in);
if(scanner.hasNextInt());//判断是否有值
int i=scanner.hasNextInt();//进行赋值操作
scanner.close();//关闭scanner

2.增强for循环

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

数组

1.数组

int[] num; //数组的声明
num= new int[10]; //数组的创建
//int[] num=new int[10];

2.JAVA内存分析

堆：存放new的对象和数组；可以被所有线程共享，不会存放别的对象引用。

栈：存放基本变量类型（包括基本类型的具体数值），引用对象的变量（存放的是具体的位置）。

ArrayIndexOutOfBoundsException：数组下标越界异常。

3.Array类

数组的工具类java.util.Arrays

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接调用，不用通过使用对象进行调用

常用的功能：

• 给数组赋值：fill方法
• 对数组排序：sort方法，升序
• 比较数组：通过equals方法进行比较元素是否相等
• 查找数组元素：用过binarySearch方法能对排序好的数组进行二分查找操作。

类

构造器：

和类名相同，没有返回值

作用：new 本质在调用构造方法， 初始化对象的值

注意点：定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

alt+insert 快捷键

类Person1 自己不手动添加任何无参或有参数构造方法 （实例化对象时：编译通过）
类Person2 自己添加无参的构造方法 （实例化对象时：编译通过）
类Person3 有参数的构造方法 （实例化对象时：不通过）
类Person4 自己添加无参的构造方法,和有参数的构造方法 （实例化对象时：编译通过）
————————————————

//定义类Person1   自己不手动添加任何无参或有参数构造方法

class Person1{
    private int age;
    private String name;
    private String sex;

}


//定义类Person2   自己添加无参的构造方法

class Person2{
    private int age;
    private String name;
    private String sex;
    
    public Person2(){
        System.out.println("无参构造方法被调用");
    }
}


//定义类Person3   有参数的构造方法

class Person3{
    private int age;
    private String name;
    private String sex;
    
    public Person3(String name, String sex, int age ){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}


//定义类Person4   自己添加无参的构造方法,和有参数的构造方法

class Person4{
    private int age;
    private String name;
    private String sex;
    
    //不带参数的构造函数，可以被重载
    public Person4(){
        System.out.println("无参构造方法被调用");
    }
    
    //带参数对的构造函数
    public Person4(String name, String sex, int age ){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}


public class ObjectInit_2 {
    public static void main(String[] args) {
        Person1 person1 = new Person1();//编译通过；①实例化Person对象    ②自动调用构造方法Person( )

        Person2 person2 = new Person2();//编译通过；打印: 无参构造方法被调用


        // 这样写，编译器会报错，原因是系统默认的无参构造方法被有参构造方法覆盖，编译器不能再提供无参构造方法
        Person3 person3 = new Person3();

        //Person4 person4 = new Person4();//编译通过；打印: 无参构造方法被调用

        Person4 person4 = new Person4("qzz", "man", 18);//编译通过；
    
    }
}

this
在每个类的内部，都有一个隐含的成员变量，该类的类型就是该类的类型，该成员变量的名称是this，this是一个引用，指向自身的对象。
this的用法：
1、this调用本类中的属性，也就是类中的成员变量
2、this调用本类中的其他方法
3、this调用本类中的其他构造方法，调用时要放在构造方法的首行

子类继承父类的语法格式如下：
修饰符 class subclass extends superclass {……}
public class Animal {
private String name;
private int age;

public void shout(){
System.out.println(“我的叫声很好听…”);
}
//省略get、set方法
}

Java继承：
1、Java只支持单继承，也就是只能继承一个类
2、如果一个类没有声明继承关系。默认继承Object类
3、子类继承父类全部的操作（除了构造方法），如果父类中的属性是private的，属于隐式继承，不能直接 操作，可以通过set、get方法进行操作
在子类中，可以根据需要对从基类中继承来的方法进行重写
重写方法必须和被重写方法具有相同的方法名称、参数列表、和返回类型
重写方法不能使用比被重写方法更更严格的访问权限

Super：是直接父类对象的引用可以通过super访问父类汇中被子类覆盖的方法或属性
普通方法：没有顺序，任意调用
构造方法：任何类的构造方法中，如果构造方法中没有显示的调用super(…),那么Java 会默认调
用super()作为父类的初始化方法，所以在写不写super()方法，没 有关系

异常

异常的情况：

RuntimeException(运行时异常)

• ArrayIndexOutOfBoundsException（数组下标越界）
• NullPointerException（空指针异常）
• ArithmeticException（算数异常）
• MissingResourceException(丢失资源)
• ClassNotFoundException（找不到类）

异常处理机制

try{//监控区域} catch(异常类型){//捕获异常} finally{//处理善后工作}

finally可以不要，但是try catch必须要

快捷键：选中那行代码 CTRL+ALT+T 将代码包裹起来

JAVA中的常用类

1.String类

1》判断功能

equals(Object obj):比较两个字符串是否相等
equalsIngnoreCase(Object obj):忽略大小写比较两个字符串是否相等
contains(String str):是否包含指定字符串
startsWith(String str):是否以指定的字符串开头
endWith(String str):是否以指定的字符串结尾
isEmpty():是否为空
matches(String regex):判断字符串是否匹配给定的正则表达式。

2》获取功能

length():获取长度
charAt(int index): 获取指定索引位置处的字符
indexOf(int ch):获取指定字符第一次出现的索引值(从0开始)
indexOf(int ch,int fromIndex):获取从指定索引位置开始，获取指定字符第一次出现的索引值
indexOf(String s):获取指定字符串第一次出现的索引值
indexOf(String s,int fromIndex):获取从指定索引位置开始，获取指定字符串第一次出现的索引值
lastIndexOf(int ch):获取指定字符最后一次出现的索引值
substring(int start):从指定位置开始一直截取到末尾
substring(int start,int end):截取[start,end-1]范围

3》转换功能

byte[] getBytes():将字符串转成字节数组
char[] toCharArray():将字符串转成字符数组
static valueOf(char[] chs):将char[]转成字符串
static valueOf(int num):将int类型转成字符串
static valueOf(Object obj):将任意类型转成字符串
toLowerCase():转成小写
toUpcase():转成大写
concat(String str):字符连接

4》其他功能

replace(char old,char new):将old字符替换成new字符
replace(String old,String new):将old字符串替换成new字符串
trim():去除两边空格
int compareTo(String s):字典比较，如果前面值小于后面值返回负数，否则返回正数，先比较第一个元素，如果相等再比较第二个元素…返回元素之间的差值；如果比较字符串有包含关系，返回的值是它们长度的差值
int compareToIgnoreCase(String s):忽略大小写字典比较

String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[] split(String regex): 根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit): 根据匹配给定的正则表达式来拆分此字符串。

2.Scanner类

boolean hasNext():是否有下一个数,有true，没有false
String next():获取下个数
int nextInt():获取下个int数据
String nextLine():获取一行数据

3.Math类

成员方法
abs(int a):绝对值
ceil(double d):向上取整
floor(double d):向下取整
max(int a,int b):最大值
pow(double a,double b):a的b次幂
random():随机数[0.0,1.0]
round(float f):四舍五入
sqrt(double d):算术平方根

4.Random类

1）构造方法
Random():以当前时间毫秒值作为种子，创建Random对象
Random(long seed):以指定种子创建Random对象
2）成员方法
nextInt():生成1个int类型范围的随机数
nextInt(int n):产生1个[0,n-1]范围内的随机数

生成0~n之间的数
①(int)Math.random()(n+1)
②Random r = new Random();
r.nextInt(m)表示生成[0,m-1]之间的随机数，也就是说random.nextInt(m+1)，将生成[0,m]之间的随机整数。
r.nextInt(n+1)
生成n~m之间的随机数
①n+(int)(Math.random()(m+1-n));
②Random r = new Random();
r.nextInt(m+1-n)+n;