一.关于IDEA快捷键

1.快速生成语句

快速生成main（）方法：psvm，回车

快速生成输出语句：sout，回车

2.内容辅助键

Ctrl+Alt+space：内容提示，代码补全等

快速注释方法：

单行：选中代码，Ctrl+/，再来一次就是取消

多行：选中代码，Ctrl+shift+/，再来一次，就是取消

代码格式标准化：Ctrl+Alt+L

二.数组

1.数组定义格式：数组类型[ ]变量名

例如int [ ] arr

2.动态初始化：分配内存空间，赋值

例如：int [ ] arr= new int [3]

3为数组长度，表示数组中有三个元素。

3.数组元素访问：数组名+索引

索引从0开始，每次加一。

通过数组索引更改数据会导致原始地址内数据发生改变，即会更改原始数据。

4.java中的内存分配

栈内存：存储局部变量，定义在方法中的变量，例如arr，使用完毕立即消失。

堆内存：存储new出来的内容（实体，对象），数组在初始化时，会为存储空间添加默认值。

每一个new出来的东西都有一个地址值，使用完毕会在回收器空闲时被回收。

5.静态初始化

int [ ] arr = new int [ ]{1,2,3}

简化成int [ ] arr = {1,2,3}

直接赋值

6.数据操作常见问题

1）索引越界

索引数超过数组长度。

2）空指针异常

即默认值null无有效对象。

7.常见操作

1.获取数组元素数量

public static void Arr(){
int [] arr = {1,2,3};
    System.out.println(arr.length);//arr.length获取数组长度
}

2.遍历数组

//输出数组中的所有元素
public static void Arr(){
int [] arr = {1,2,3};
    for(int i = 0;i<arr.length;i++){
        System.out.println(arr[i]);
    }
}

//输出[8,7,6,5,4]

public static void Arr() {
    int[] arr = {8,7,6,5,4};
    System.out.print("[");
    for (int i = 0; i < arr.length; i++) {
        if (i < arr.length - 1) {
            System.out.print(arr[i] + ",");
        } else {
            System.out.print(arr[i] + "]");
        }
    }
}

3.求数组最值

//找最大值
public static void Arr1() {
    int[] arr = {2, 3, 4, 7, 4, 2};
    int max = 0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        } else {
            max = max;
        }
    }
    System.out.println(max);
}

三.方法

1.方法定义和调用

方法定义：

public static void 方法名（）{

//方法体

}

方法调用：

方法名（）；

public class HelloWorld {
    public static void main(String[] args) {
        Arr1();
    }

    public static void Arr1() {
        int[] arr = {2, 3, 4, 7, 4, 2};
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            } else {
                max = max;
            }
        }
        System.out.println(max);
    }
}

2.带参数方法的定义和调用

单参数

//给定参数判断是否为偶数

public class HelloWorld {
    public static void main(String[] args) {
        Arr2(20);//常量调用
        int number = 20;
        Arr2(number);//变量调用
    }

    public static void Arr2(int number){
        if(number%2==0){
            System.out.println(true);
        }else {
            System.out.println(false);
        }
    }
}

3.形参、实参

形参：方法定义中的参数，如int number；

实参：方法调用中的参数，如number，20。

4.带返回值的方法和调用

//给定参数判断是否为偶数

public class HelloWorld {
    public static void main(String[] args) {
        boolean f = Arr2(10);
        System.out.println(f);
    }

    public static boolean Arr2(int number){
        if(number%2==0){
            return true;
        }else {
            return false;
        }
    }
}

方法的返回值要用变量接收。

5.注意事项

1.方法不能嵌套定义，方法中不能定义另一个方法，但是可以调用其他方法。

2.void无返回值，但是可以有return，表示方法结束。

public class HelloWorld {
    public static void main(String[] args) {
        int f = Measure(10,30);
        System.out.println(f);
    }

    public static int Measure(int a,int b){
        if(a>b){
            return a;
        }else {
            return b;
        }
    }

}

6.方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件：

1.多个方法在同一个类中。

2.多个方法具有相同的变量名。

3.多个方法参数、类型、或者数量不同。

4.重载仅对应方法的定义，与方法的调用无关。

5.不能通过返回值来判断方法是否构成重载。

例如：

public class HelloWorld {
    public static void main(String[] args) {
        boolean f = Compare(10.31,39.33);
        System.out.println(f);
    }

    public static boolean Compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    public static boolean Compare(double a, double b) {
        System.out.println("double");
        return a == b;
    }
}

四.封装

1.private

1.private作用

作为权限修饰符，可以修饰成员，保护成员不被别的类使用。

private修饰的成员只能在本类中使用。

2.private在其他类使用

使用get变量名：获取值，用public修饰；

使用set变量名：设置值，用public修饰。

例如：

public class Practise {
        String name;
        private int age;
        public void setAge(int a){
            if(a<0||a>120){
                System.out.println("输入错误！");
            }else {
                age=a;
            }
        }
        public int getAge(){
            return age;
        }
        public void Show(){
            System.out.println(name+","+age);
        }
}

public class PractiseDemo {
    public static void main(String[] args) {
        Practise s = new Practise();
        s.name="唐老鸭";
        s.setAge(-56);
        s.Show();
    }
}

2.this关键字

this+名称指代长远变量，解决局部变量隐藏成员变量。

1.方法的形参如果与成员变量同名，不带this修饰的变量是形参，而不是成员变量。

2.方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。

3.方法被哪个对象调用，this就代表哪个对象。

3.封装

1.封装概述

面向对象三大特征：封装，继承，多态。

封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作。

2.封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXXX/setXXX方法。

3.封装好处

通过方法来控制成员变量的操作，提高了代码的安全性。

把代码用方法进行封装，提高了代码的复用性。

例子：

//带参构造方法
public class Practise {

    private String name;
    private int age;

    public Practise() {
    }                           //无参构造

    public Practise(String name) {
        this.name = name;
    }

    public Practise(int age) {
        this.age = age;
    }

    public Practise(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void Show(){
        System.out.println(name+","+age);
    }
}

public class PractiseDemo {
    public static void main(String[] args) {

        Practise s1 = new Practise();
        s1.Show();
        Practise s2 = new Practise("唐老鸭",76);
        s2.Show();
        Practise s3 = new Practise("白雪公主",56);
        s3.Show();
        Practise s4 = new Practise("米老鼠",76);
        s4.Show();
    }
}

//无参和带参构造方法

public class Practise {
    private String name;
    private int age;

    public Practise() {
    }
    public Practise(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void Show(){
        System.out.println(name+","+age);
    }
}

public class PractiseDemo {
    public static void main(String[] args) {
        //无参创建，set赋值
        Practise s1 = new Practise();
        s1.setName("唐老鸭");
        s1.setAge(87);
        s1.Show();
        //带参直接创建
        Practise s2 = new Practise("唐老鸭",87);
        s2.Show();
    }
}

无论是否使用无参构造方法，都推荐书写无参数构造方法。

四.字符串

1.API应用程序编程接口

2.String

    String s1 = new String();
    System.out.println(s1);
    char[] chs = {'a','b','c'};
    String s2 = new String(chs);
    System.out.println(s2);
    byte[] bys = {97,98,99};
    String s3 = new String(bys);
    System.out.println(s3);
    String s4 = "dawd";//最常用
    System.out.println(s4);

3.字符串比较

基本类型：数值相同

引用类型：地址相同

字符串比较所用方法：equals()

案例：用户登录。

package dailySchedu;
import java.util.Scanner;
public class Dl {
    public static void main(String[] args) {
        String s11 = "123";
        String s21 = "123";
        while (true) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入账号：");
        String s1 = sc.nextLine();
        System.out.println("请输入密码");
        String s2 = sc.nextLine();
            if (s1.equals(s11)&&s2.equals(s21)) {//比较字符串内容，严格区分大小写
                System.out.println("登陆成功！");
                break;
            } else {
                System.out.println("输入失败请重新登录：");
            }
        }
    }
}

4.字符串操作

System.out.println(line.charAt(i));//输出字符串中索引为i的字符
System.out.println(line.length());//字符串长度

//字符串反转

import java.util.Scanner;
public class Dl {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        String ss = "";
        for(int i = s.length()-1;i>=0;i--){
            ss+=s.charAt(i);
        }
        System.out.println(ss);
    }
}

5.StringBuilder

String使用时内容不可变；

StringBuilder无需导包，内容可变。

public StringBuilder()//创建空白可变，无内容
public StringBuilder(String str)//创建可变字符串对象

关于StringBuilder的添加和反转方法：

public StringBuilder append(){}//添加数据返回对象本身
public StringBuilder reverse(){}//返回相反的字符序列

例子：

public class Dl {
    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();
        s.append("a").append("b").append("c");
        System.out.println(s);//输出abc
        s.reverse();
        System.out.println(s);//输出cba
    }
}

6.String和StringBuilder相互转换

1.StringBuild转化为String

public String toString；

2.String转化为StringBuilder

public StringBuilder(String s);

例子：

String ss = s.toString();//StringBuild转化为String
StringBuilder sss = new StringBuilder(s);//String转化为StringBuilder