基础-训练营-day1~day5

基础

大纲
  变量:
      声明、初始化、使用、命名
  数据类型:
      int、long、double、boolean、char、String
  运算符:
      赋值、算术、关系、逻辑
  分支结构:
      if、if...else、if...else if
  循环结构:
      循环、三要素、while、for

Java开发环境:
  1)java编译运行过程:------常见面试题
    1.1)编译期:.java源文件，经过编译，生成.class字节码文件
    1.2)运行期:JVM加载.class并运行.class
    跨平台、一次编程到处使用

2)名词解释:--------------常见面试题
    2.1)JVM:java虚拟机
            加载.class并运行.class
    2.2)JRE:java运行环境
            除了包含JVM以外还包含运行java程序所必须的环境
            JRE=JVM+java系统类库(后期讲)
    2.3)JDK:java开发工具包
            除了包含JRE以外还包含开发java程序所需要的命令工具
            JDK=JRE+编译、运行等命令工具
    运行java程序的最小环境为JRE
    开发java程序的最小环境为JDK

3)配置环境变量-------过几天回头看
    3.1)JAVA_HOME:指向jdk的安装路径
    3.2)CLASSPATH:表示类的搜索路径，一般简写为.
    3.3)PATH:指向jdk下的bin目录
Helloworld：

package day01;    //声明表day01(绿色表示注释)

public class HelloWorld {
    public static void main(String[] args){ //class声明类名HelloWorld
    //主方法，为程序的入口
        //程序的执行从main开始，main结束则程序结束
        /*
         * 1.java是严格区分大小写的，红色曲线表示错误；
         * 2.所有符号必须是英文模式；
         * 3.每句话必须以分号结尾System.out.println("")；
         * 4.文件名前边有*表示文件没有保存。
         */
        System.out.println("HellowWorld");
    }
}

数据类型:
  1)int:整型，只能装整数，-21个多亿到21个多亿
        5,25,250...
  2)long:长整型，只能装整数，很大很大很大
         250L,10000000000L...
  3)double:浮点型，只能装小数，很大很大很大
           3.14,25.678,5.0...
  4)boolean:布尔型，只能装true和false
            true,false
  5)char:字符型，字符必须放在单引号中，有且仅有一个
         '男','m','7',' '...
  6)String:字符串型，字符串必须放在双引号中，0个到多个
           "你好吗?","abc","男",""...

数据类型应用示例

package day02;
//数据类型的演示
public class DataTypeDemo {
    public static void main(String[] args) {

        /*
        //6.String:字符串型，字符串需放在双引号中，0个到多个
        String s1 = "Hello"; //声明字符串型变量s1并赋值为Hello
        String s2 = "你好"; //声明字符串型变量s2并赋值为你好
        String s3 = "我";
        String s4 = ""; //声明字符串型变量s4并赋值为空字符串
        //String s5 = 中国; //编译错误，必须放在双引号中
        */

        /*
        //5.char:字符型，字符需放在单引号中，有且仅有一个
        char c1 = '女'; //声明字符型变量c1并赋值为字符女
        char c2 = 'f'; //声明字符型变量c2并赋值为字符f
        char c3 = '6'; //声明字符型变量c3并赋值为字符6
        char c4 = ' '; //声明字符型变量c4并赋值为空格符
        //char c5 = 男; //编译错误，字符必须放在单引号中
        //char c6 = ''; //编译错误，必须有字符
        //char c7 = '中国'; //编译错误，只能有一个字符
        */

        /*
        //4.boolean:布尔型，只能装true和false
        boolean a = true; //声明布尔型变量a并赋值为true
        boolean b = false; //声明布尔型变量b并赋值为false
        //boolean c = 3.14; //编译错误，数据类型不匹配
        */

        /*
        //3.double:浮点型，只能装小数，很大很大很大
        double a = 3.14159; //声明浮点型变量a并赋值为3.14159
        double b = 25;
        System.out.println(b); //25.0
        */

        /*
        //2.long:长整型，只能装整数，很大很大很大
        long a = 250L; //声明长整型变量a并赋值为250
        long b = 10000000000L; //声明长整型变量b并赋值为100亿
        //long c = 3.14; //编译错误，长整型只能装整数
        */

        /*
        //1.int:整型，只能装整数，-21个多亿到21个多亿
        int a = 250; //声明整型变量a并赋值为250
        //int b = 10000000000; //编译错误，超出范围了
        //int c = 3.14; //编译错误，整型只能装整数
        */
    }
}

运算符:

1)赋值运算符:=
   2)算术运算符:+-*/%,++,--
   3)关系运算符:>,<,>=,<=,==,!=
              　　 boolean
   4)逻辑运算符:&&,||,!

运算符应用示例：

package day03;
//运算符的演示
public class OperDemo {
    public static void main(String[] args) {    

        /*
         * 4.逻辑运算符:
         *   1)&&:逻辑与(并且)，两边都为真则为真，见false则false
         *     ||:逻辑或(或者)，有一边为真则为真，见true则true
         *      !:逻辑非(取反)，非真则假，非假则真
         *   2)逻辑运算是建立在关系运算的基础之上的，
         *     逻辑运算的结果也是boolean型
         */

        /*
        int a=5,b=10,c=5;
        boolean b2 = !(a>b);
        System.out.println(b2);     //!false=true
        System.out.println(!(c<b)); //!true=false
        */
        /*
        System.out.println(a>=c || a>b); //true||false=true
        System.out.println(b<=c || b>a); //false||true=true
        System.out.println(a==c || b>a); //true||true=true
        System.out.println(a!=c || b<c); //false||false=false
        */
        /*
        boolean b1 = a>=c && a>b;
        System.out.println(b1);          //true&&false=false
        System.out.println(b<=c && b>a); //false&&true=false
        System.out.println(a!=c && b<c); //false&&false=false
        System.out.println(a==c && b>a); //true&&true=true
        */

        /*
         * 3.关系运算符:
         *   1)>(大于),<(小于)
         *     >=(大于或等于),<=(小于或等于)
         *     ==(等于),!=(不等于)
         *   2)关系运算的结果为boolean型，
         *     关系成立则为true，关系不成立则为false
         */
        /*
        int a=5,b=10,c=5;
        boolean b1 = a>b;
        System.out.println(b1);   //false
        System.out.println(c<b);  //true
        System.out.println(b>=a); //true
        System.out.println(a<=c); //true
        System.out.println(a==c); //true
        System.out.println(a!=c); //false
        */

        /*
         * 2.算术运算符:+,-,*,/,%,++,--
         *   1)/:两个整数相除，结果还是整数，小数位无条件舍弃
         *   2)%:取模/取余，余数为0即为整除
         *   3)++/--:自增1/自减1，可在变量前也可在变量后
         *     3.1)单独使用时，在前在后无差别
         *     3.2)被使用时，在前在后有差别
         *           a++的值为a
         *           ++a的值为a+1
         */

        /*
        int a=5,b=5;
        //1)输出a++的值5
        //2)a自增1变为6
        System.out.println(a++); //5
        System.out.println(a);   //6
        //1)输出++b的值6
        //2)b自增1变为6
        System.out.println(++b); //6
        System.out.println(b);   //6
        */

        /*
        int a = 5;
        int b = ++a; //1)将++a的值6赋值给b  2)a自增1变为6
        System.out.println(a); //6
        System.out.println(b); //6
        */
        /*
        int a = 5;
        int b = a++; //1)将a++的值5赋值给b  2)a自增1变为6
        System.out.println(a); //6
        System.out.println(b); //5
        */

        /*
        int a = 5;
        ++a; //相当于a=a+1
        System.out.println(a); //6
        */
        /*
        int a = 5;
        a++; //相当于a=a+1
        System.out.println(a); //6
        */

        /*
        System.out.println(5%2); //1，商2余1
        System.out.println(6%2); //0，商3余0--整除
        System.out.println(2%6); //2，商0余2

        System.out.println(5/2);   //2
        System.out.println(6/2);   //3
        System.out.println(2/6);   //0
        System.out.println(5/2.0); //2.5
        */

        /*
        //1.赋值运算符:=
        int a = 5; //声明整型变量a并赋值为5
        a = a+10; //取出a的值5，加10后，再赋值给a
                  //在a本身基础之上增10
        System.out.println(a); //15
        */
    }
}

 if , else,   else if,语法

1.分支结构:有条件的执行某语句，并非每句必走
  1)if:1条路
    1.1)语法:
          if(boolean){
            语句块
          }
    1.2)执行过程:
          判断boolean的值:
            若为true，则执行语句块
            若为false，则不执行语句块
  2)if...else:2条路
    2.1)语法:
          if(boolean){
            语句块1
          }else{
            语句块2
          }
    2.2)执行过程:
          判断boolean的值:
            若为true，则执行语句块1
            若为false，则执行语句块2
  3)if...else if:多条路
    3.1)语法:
          if(boolean-1){
            语句块1
          }else if(boolean-2){
            语句块2
          }else if(boolean-3){
            语句块3
          }else{
            语句块4
          }
    3.2)执行过程:
          判断boolean-1，若为true则执行块1，若为false则
          再判断boolean-2，若为true则执行块2，若为false则
          再判断boolean-3，若为true则执行块3，若为false则执行块4
    3.3)说明:
        3.3.1)块1234，只有可能走其中之一
        3.3.2)若没有最后的else，则块123并非必走其中之一
        3.3.3)若有最后的else，则块1234必走其中之一

if  else应用示例：

package day04;
//if...else if结构的演示
public class IfElseIfDemo {
    public static void main(String[] args) {
        /*
         * 分支结构的练习:
         * 1.完成成绩等级判断案例
         * 2.完成如下三个需求:
         *   需求1:满500打8折，不满500不打折
         *   需求2:满500打8折，不满500打9折
         *   需求3:满1000打7折，500到999打8折，不满500打9折
         */

        /*
        //需求3:满1000打7折，500到999打8折，不满500打9折
        double price = 295.0;
        if(price>=1000){
            price=price*0.7;
        }else if(price>=500){
            price=price*0.8;
        }else{
            price=price*0.9;
        }
        System.out.println(price);
        */

        /*
        //需求2:满500打8折，不满500打9折
        double price = 600.0;
        if(price>=500){
            price = price*0.8; //打8折
        }else{
            price = price*0.9; //打9折
        }
        System.out.println(price);
        */

        /*
        //需求1:满500打8折，不满500不打折
        double price = 1000.0;
        if(price>=500){ //满500
            price = price*0.8; //打8折
        }
        System.out.println(price);
        */

        /*
         * 3.if...else if结构:多条路
         *   1)语法:
         *       if(boolean-1){
         *         语句块1
         *       }else if(boolean-2){
         *         语句块2
         *       }else if(boolean-3){
         *         语句块3
         *       }else{
         *         语句块4
         *       }
         *   2)执行过程:
         *       判断boolean-1，若为true则执行块1，若为false则
         *       再判断boolean-2，若为true则执行块2，若为false则
         *       再判断boolean-3，若为true则执行块3，若为false则执行块4
         *   3)说明:
         *     3.1)块1234，只可能走其中之一
         *     3.2)若没有最后的else，则块123并非必走其中之一
         *     3.3)若有最后的else，则块1234必走其中之一
         */

        /*
        int score = 45; //成绩
        if(score>=90){
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }
        */
    }
}

 for，while循环结构:
  1)while:
    1.1)语法:
          while(boolean){
            循环体--反复执行的语句
          }
    1.2)执行过程:
          判断boolean的值，若为true则执行循环体，
          再判断boolean的值，若为true则执行循环体，
          再判断boolean的值，若为true则执行循环体，
          以此类推，直到boolean为false时循环结束
  2)for:
    2.1)语法:
                1     2     3
          for(要素1;要素2;要素3){
            循环体--反复执行的语句   4
          }
    2.2)执行过程:
          12432432432432432432

while循环应用演示：

package day05;
//while循环的演示
public class WhileDemo {
    public static void main(String[] args) {

        /*
         * while的练习:
         * 1.完成如下案例:
         *   1)输出10次"失败是成功之母"
         *   2)输出9的乘法表(正序)
         *   3)输出9的乘法表(倒序)
         *   4)跑3圈
         *   5)打印10份简历
         * 2.如上案例任选其二写执行过程
         */

        /*
         * 1.while结构:
         *   1)语法:
         *       while(boolean){
         *         语句块---循环体(反复干的那个事)
         *       }
         *   2)执行过程:
         *       判断boolean，若为true则执行语句块，
         *       再判断boolean，若为true则执行语句块，
         *       再判断boolean，若为true则执行语句块，
         *       如此反复，直到boolean为false时循环结束
         */

        /*
        int num=10;
        while(num>0){
            System.out.println("打印一份");
            num--;
        }
        System.out.println("over");
        */

        /*
        int count=0;
        while(count<3){
            System.out.println("跑一圈");
            count++;
        }
        System.out.println("over");
        */

        /*
        int num=9;
        while(num>=1){
            System.out.println(num*9);
            num--;
        }
        System.out.println("over");
        */

        /*
        int num=1;     //1.循环变量的初始化
        while(num<=9){ //2.循环的条件
            System.out.println(num*9);
            num++;     //3.循环变量的改变
        }
        System.out.println("over");
        */
        /*
         * 执行过程:
         * num=1 true 输出9
         * num=2 true 输出18
         * num=3 true 输出27
         * num=4 true 输出36
         * num=5 true 输出45
         * num=6 true 输出54
         * num=7 true 输出63
         * num=8 true 输出72
         * num=9 true 输出81
         * num=10 false while循环结束
         * 输出over
         */

        /*
        int times=0;     //1.循环变量的初始化
        while(times<10){ //2.循环的条件
            System.out.println("失败是成功之母");
            times++;     //3.循环变量的改变
        }
        System.out.println("over");
        */
        /*
         * 执行过程:
         * times=0 true 输出
         * times=1 true 输出
         * times=2 true 输出
         * times=3 true 输出
         * times=4 true 输出
         * times=5 true 输出
         * times=6 true 输出
         * times=7 true 输出
         * times=8 true 输出
         * times=9 true 输出
         * times=10 false while循环结束
         * 输出over
         */
    }
}

for循环应用演示：

package day05;
//for循环的演示
public class ForDemo {
    public static void main(String[] args) {
        /*
         * 练习:
         * 1.for循环方式完成案例一和案例二
         * 2.任选其一写执行过程
         */

        /*
        //案例二.输出9的乘法表:
        for(int num=1;num<=9;num++){
            System.out.println(num*9);
        }
        System.out.println("over");
        */
        /*
        //案例一.输出10次"失败是成功之母":
        for(int count=0;count<10;count++){
            System.out.println("失败是成功之母");
        }
        System.out.println("over");
        */
        /*
         * 执行过程:
         * count=0 true 输出
         * count=1 true 输出
         * count=2 true 输出
         * count=3 true 输出
         * count=4 true 输出
         * count=5 true 输出
         * count=6 true 输出
         * count=7 true 输出
         * count=8 true 输出
         * count=9 true 输出
         * count=10 false for循环结束
         */

    }
}