一.标识符

1.1Mul:错误
2.pri_div:正确
3.goto:错误
4.may be:错误
5.MulForm:正确,并在一定程度上显示了自身的含义5.MulForm:正确,并在一定程度上显示了自身的含义

二.变量的作用域

1.局部变量:

for(int i;;){

}
System.out.println(i);
//报错,i在for循环结束时被销毁

2.全局变量:
(1).有默认值
(2).可以被访问修饰符修饰,且访问修饰符决定其使用范围
3.静态变量:
被所有实例所共用,且有默认值

三.运算符

1.算术运算符:
(1)."/" 若两侧均为整型数,那么商也会取整

int i = 5;
int j = 9;
System.out.println(i/j);//0

若要输出小数,可以将i或j的任意一项或两项转为浮点数
(2).a++,++a的区别(--逻辑相同):
运算逻辑的先后不同:

int i = 5;
j = i++;//j = 5,i = 6
a = ++i;//a = 7 = i

int i = 5,j = 6;
if(i++ == 6 && ++j == 7){
//关于这个问题,i++ == 6,是在i = 5时与6相比
//所以这项错误,if内语句无法输出,
//为何j = 6,
//因为&&有截断效果,若第一项错误,则后项则不判断,直接跳出
i = 17;
j = 11
}
System.out.println(i);//6
System.out.println(j);//6

2.逻辑运算符:
&&和||都有类似的截断效果,若&&第一项错误,后项不予判断,若||第一项正确,则后项不予判断
3.赋值运算符:
可以省略类似a = a + 2;的繁复过程,直接a += 2;
此外,赋值运算符有自带的强转

byte i = 3;
i = i + 2;会报错
i += 2;不会报错

四.分支

1.if-else if-else

//输出闰年
import java.util.Scanner;
public class RunNian{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
if((n % 4 == 0 && n % 100 != 0) || n % 400 == 0){
System.out.println(n + "年是闰年")
}
}
}

2.switch:
(1).若通过了一个case,那么后续case不再判断,直接输出,直到遇见break或default
(2).case后接的值不可以使用变量
(3).若没有设置default,在程序执行完后也会退出
(4).多个case可以对应同一输出结果

case 1:
case 2:
case 3:
System.out.println();
break;

五.循环

1.

for((最先执行,且只执行一次)循环变量初始化;1.循环条件;3.循环变量迭代){
    2.语句块
}

也可以这么写

循环变量初始化
for(;循环条件;){
语句块
循环变量迭代
}
(其中;不可缺少)

2.for-each
for(数据类型 标识符:要遍历的数组或集合)
3.while(condition)
当condition为true时执行代码块
4.do-while
无论如何至少执行一次的循环

六.类与对象:

1.静态方法:可以通过类名使用,Math是典型的静态方法集
2.非静态方法在使用前要创建对象,以对象.方法名(参数)的方式使用
3.静态方法只可以使用静态变量和局部变量
4.private修饰的变量不可以通过(对象名.变量名)修改,就要借用构造器和set的方法去修改

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int r1 = scanner.nextInt();
        int r2 = scanner.nextInt();
        System.out.println(AreaCalculation.PI);
        AreaCalculation a = new AreaCalculation(r1,r2);
        System.out.println(a.add());
        AreaCalculation.AreaCal(r1,r2);
    }
}

class AreaCalculation {
    private int r1;
    private int r2;
    private int rSum;
    public static double PI = 3.14;

    public AreaCalculation(int r1, int r2) {
        this.r1 = r1;
        this.r2 = r2;
    }

    public int add() {
        rSum = r1 + r2;
        return rSum;
    }

    public void setr1(int r1) {
        this.r1 = r1;
    }

    public int getr1() {
        return r1;
    }
    //r2同理,不过多赘述

    public static void AreaCal(int r1,int r2) {
        for (int i = r1; i <= r2; i++) {
            double area = PI * Math.pow(i, 2);
            System.out.println(area);
        }
    }
}

5.封装可以避免内部数据被篡改,也可以让用户不需了解内部运行的情况下使用

七.数组

1.多维数组从第二维开始的内存可以待定,便于后续使用,杨辉三角的实现就是使用了二维数组的待定

public class YangHui{
    public static void main(String[] args){
        int[][] arr = new int[10][];//定义一个10行的数组
        for(int i = 0;i < arr.length;i++){
            arr[i] = new int[i + 1];//对每行数组进行列数赋值
            for(int j = 0;j < arr[i].length;j++){
                if(j == 0 || j == i){
                    arr[i][j] = 1;//对数组进行赋值
                }else{
                arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
            }
            }
        }
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

2.for-each仅是对数组的拷贝,不会影响数组本身,但是以for遍历会改变数值

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr){
            i++;
            System.out.println(i);//2,3,4,5,6
        }
        for(int i : arr){
            System.out.println(i);//1,2,3,4,5
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i]++;
            System.out.println(arr[i]);//2,3,4,5,6
        }
        for(int i : arr){
            System.out.println(i);//2,3,4,5,6
        }
    }
}

3.可变参数:
数据类型... 标记符
基本可以当作数组看待
一个方法中不可以有两个以上的可变参数,且可变参数要放于形参列表最后

八.继承

class 子代 extends 父代{

}

1.子代可以继承父代的所有方法,并且可以进行改写
2.子代最多只能有一个父代
3.若父代有构造器将无参构造器掩盖,创造子代时报错,有以下方法解决
(1).在父代中创建一个无参构造器
(2).在子代的构造方法中使用super来使用父代构造器
(3).在子代中对父代的构造器进行改写

cuienzhuo