A Java基础整合---从配置环境变量到完成学生管理系统

public class HelloWord {
    public static void main(String[] args) {
        System.out.println("HelloWrod");
    }
}

以下语句会不会报错？为什么？
  short num1 = 10,num2;
        byte num3 = 20;
        num2 = num1+num3;      //第一句
        //---------------------------------------------------
        num2 = 200+30;    //第二句
        //-------------------------------------------------
        num3 = 120+10;      //第三句
        //-------------------------------------------------
        //解析
        /*
    第一句：会报错，这边存在一个隐式转换；【任何整型变量在计算时都会默认转为int类型】再做计算；此处num1与num3会先转int计算完再赋值，然而num2是short类型，大类型值赋值给小类型会报错；
    第二句：不会报错，此处存在常量优化机制，因为200与30都是常量，在编译过程中会将结果计算出来，再给num2赋值；num2是short类型230在它的范围内；所以不会出错；
    第三句：会报错，虽然java有常量优化机制，但是，此处优化后的结果是130，超出了byte的范围；【byte范围：-128----+127】
  */

int  num2  = 20;  //把 常量20赋给num2
  //-----------------------------------------------
  byte num3 = 20;
        num3 += 20; //此处实质是：num3 = (num3类型)（num3+20）

|        // 逻辑或
^        // 逻辑异或
||   // 短路或

int num1 = 20;
        int num2 = 30;
        num1 = num1+num2;
        num2 = num1-num2;
        num1 = num1-num2;

int num1 = 20;
        int num2 = 30;
        num1 = num1^num2;
        num2 = num1^num2;
        num1 = num2^num1;

//数组定义初始化完整格式
        int [] arr1 = new int[]{1,2,3};
        //数组定义初始化简化格式
        int [] arr2 = {1,2,3};

int [] arr3;//定义数组
  arr3 = new int[10];//动态初始化
  arr3[0] = 15;
  arr3[1] = 20;
  .
  .
  .
  arr[9] = 9

int [] arr2 = {1,2,3};
 System.out.println("arr2数组中第一元素为："+arr2[0]);

int [] arr2 = {1,2,3};//定义，静态初始化数组
for (int i = 0; i < arr2.length; i++) {
    System.out.println("数组值："+arr2[i]); //遍历输出arr2数组中的每个元素
}

int [] arr4 = {1,2,3,4};   //静态初始化数组
        int sum =0;
        for (int i = 0; i < arr4.length; i++) {
            if (arr4[i]%2==0){  //通过取模筛选出所有偶数
                sum += arr4[i]; //累加计算偶数和
            }
        }
        System.out.println("数组元素中所有偶数和为："+sum); //输出偶数和

public static void main(String[] args) {
        int [] arr5 = {1,15,20,9,88,8}; //静态初始化数组
        for (int i = 1; i < arr5.length; i++) {
            if (arr5[0]<arr5[i]){ //筛选出大于arr5[0]的数
                arr5[0] = arr5[i];//将筛选出的数，赋值给arr5[0]
            }
        }
        int max = arr5[0];    //将arr5[0]赋值给max变量
        System.out.println("次数组最大值为："+max);
    }

public static void main(String[] args) {
        int [] arr = new int [7]; //动态初始化一个长度为10的数组
    }

Exception in thread "main" java.lang.NullPointerException
  at HelloWord.main(HelloWord.java:8)

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体");  //判断条件为false，此语句不执行；
}

/*
考试奖励：
    分数>=90:奖励自行车一辆
    90>分数>=80:奖励游乐园一日游
    80>分数:一顿狂揍
*/
public class IfTest {
    public static void main(String[] args) {
        int chengji;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩：");
           chengji = sc.nextInt();
           if (chengji <=100 && chengji>=0){
               if (chengji>=90){
                   System.out.println("恭喜！奖励自行车一辆！");
               }else if (chengji>=80 && chengji<90){
                   System.out.println("恭喜！奖励游乐园一日游！");
               }else{
                   System.out.println("来吧一顿接受狂揍！");
               }
           }else{
               System.out.println("成绩输入有误！");
           }
    }
}

switch(variable){
           case 1:
               语句体1;
               break;
           case 2:
              语句体2;
               break;
           case 3:
               语句体3;
               break;
               .
               .
               .
           default:
               默认语句;
               break;
       }

switch(variable){
    case 1:
    case 2:
    case 3:
        //重复语句体；
        break;
    default:
        break;

switch(variable){
    case 1,2,3:
        //重复语句体；
        break;
    default:
        break;
}

System.out.println("请输入成绩：可选项【A、B、C、D】");
        switch ('B') {
            case 'A':
                System.out.println("成绩良好");
                break;
            case 'B':
                System.out.println("成绩中等");
                break;
            case 'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("成绩不合格！");
                break;
        }

public void  operator(){
    int a,b,c;
    a = 10;
    b = 20;
    //第一种情况判断条件(b>a)为真
    c = b>a ? a:b;//c的值为10；
    //第二种情况判断条件(b
    c = b
}

for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }
//在for循环中，初始化语句只执行1次；
//for循环案例：
 public static void main(String[] args) {
        for(int i =0;i<3;i++){
            System.out.println("执行第"+i+"次循环！");
        }
    }

for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }

//for循环案例3（1-100之间的偶数和）
//实现方案1
        int sum =0;
        for (int i = 1;i<=100;i++){
            if (i%2==0){
                sum += i;
            }
        }
        System.out.println("1-100之间偶数和为："+sum);
//实现方案2
        int sum =0;
        for (int i = 2;i<=100;i+=2){
                sum += i;
        }
        System.out.println("1-100之间偶数和为："+sum);

//for循环找出水仙花数
        for (int i=100;i<=999;i++){
            int ge,shi,bai; //定义各位、十位、百位变量准备后续操作
            ge = i%10;
            shi = i/10%10;
            bai = i/100;
            //用if对水仙花数条件进行筛选
            if (i==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                System.out.println("水仙花数："+i);
            }
        }

//形参
public static void prints(int num) { //此处的 num就是形参
     //方法体语句
 }
//main方法调用prints()方法时需要传实参
 public static void main(String[] args) {
          prints(5);    //此处5就是实际参数
 }

//1无参方法
    public static void prints() {
        System.out.println("*******************");
    }
//2带参方法
    //案例1 主方法：
        public static void main(String[] args) {
                //方法体语句
        }
    //案例2 自定义方法：
         public static int sum(int num1,int num2){
                int sum = num1+num2;
                return sum;//返回值
         }

public static void main(String[] args) {
        int num1 = 100; //定义变量num1
        test1(num1);    //把num1，作为参数传给test1方法
        System.out.println(num1);
    }
    public static int test1(int num1){
        return num1 = 200; //在test1方法中，给num1重新赋值
    }

public static void main(String[] args) {
        int [] num1 = {10,11}; //定义数组num1
        test1(num1);    //把num1地址，作为参数传给test1方法
        System.out.println(num1[0]);
    }
    public static int test1(int [] num1){
        return num1[0] = 200; //在test1方法中，给num1[0]重新赋值
    }

public static void prints(int freq) {
        if(freq<0 ){
            System.out.println("输入次数有误，请重新输入：");
        }else {
            for (int i = 0; i < freq; i++) {
                System.out.println("学好编程！");
            }
        }
    }

public class Students {
   int age;         //学生类成员变量age
   String name;     //学生类成员变量name
   void speak(){    //学生类成员方法speak
       System.out.println("大家好！我是"+name+"今年"+age+"岁");
   }
}

public static void main(String[] args) {
        Students zhangsan = new Students();  //创建学生对象张三
        zhangsan.age = 18;          //用对象为成员方法赋值
        zhangsan.name = "张三";       
        zhangsan.speak();          //用对象调用成员方法
    }

class Students{   //创建Students类
    String name;  //成员变量name
    int age;      //成员变量age
    //无参构造方法
    Students(){}
    //带参构造方法
    Students(int age,String name){ 
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

public class ThisDemo {
    public static void main(String[] args) {
        Students stu1 = new Students(18,"小明"); //创建对象stu1,并传参
    }
}
class Students{
    String name;  //成员变量
    int age;      //成员变量
    Students(int age,String name){ //构造方法
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

public class Studens {
    private int age;        //定义成员变量 age并私有
    private String naem;    //定义成员变量 name并私有
    public Studens() {      //无参构造
    }
    public Studens(int age, String naem) {  //带参构造
        this.age = age;
        this.naem = naem;
    }
    public void speak(){
        System.out.println("讲中国话");     // 成员方法
    }
    public int getAge() {                  //为外部提供变量访问的方法getXxx方法
        return age;
    }
    public void setAge(int age) {           //为外部提供变量访问的方法setXxx方法
        this.age = age;
    }
    public String getNaem() {               //为外部提供变量访问的方法getXxx方法
        return naem;
    }
    public void setNaem(String naem) {      //为外部提供变量访问的方法setXxx方法
        this.naem = naem;
    }
}

public static void main(String[] args) {
        boolean flag;
        //第一题
        String str1 = "hello";
        String str2 = new String("hello");
        flag = str1 == str2 ;
        System.out.println("第一题，输出为true还是false？："+flag);
        //第二题
        String str3 = "hello";
        flag = str1 == str3;
        System.out.println("第二题，输出为true还是false？："+flag);
    }

public static int countChar(String String, char cha) {
        int count = 0;                          
        char []arr = String.toCharArray();      //使用String类的toCharArray方法将字符串转为字符数组
        for (int i = 0; i < arr.length; i++) {  //for循环遍历数组
            if (cha == arr[i]){                 //if语句对比字符，用count统计
                count ++;
            }
        }
        return count;                           //返回统计数
    }

public static void numGame() {
        int count = 3;                                    //控制循环次数
        Random r = new Random();
        int num = r.nextInt(100)+91;               //生成0---100的随机数
                Scanner sc = new Scanner(System.in);
        while (count > 0){                               //循环控制输入次数
            System.out.println("请输入1--100的随机数值：");
            int numb = sc.nextInt();
            if (num==numb) {
                System.out.println("恭喜您猜对啦！");
                break;
            }else if (numb
                System.out.println("您猜的数偏小，您还有"+(count-1)+"次机会！");
                count --;
            }else {
                System.out.println("您猜的数偏大，您还有"+(count-1)+"次机会！");
                count --;
            }
        }
    }

ArrayList list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素

ArrayList list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.remove("张三");                //根据元素删除
        list1.remove(2);                    //根据索引值删除元素

list1.add("张三");                   //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");  
        list1.set(2,"年薪百万");             //修改集合数据

list1.add("张三");                        //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.get(2);                           //查找集合元素

public static void main(String[] args) {
        ArrayList list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                           //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        for (int i = 0; i < list1.size(); i++) {    //遍历集合
            String name = list1.get(i);             //获取集合元素
            if (list1.get(i).length()==4){          //判断字符串长度是否为4
                System.out.println(name);           //打印4个字的名字
            }
        }
    }