基础

大纲
  变量:
      声明、初始化、使用、命名
  数据类型:
      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：

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

数据类型:
  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","男",""...

数据类型应用示例

  1. package day02;
  2. //数据类型的演示
  3. public class DataTypeDemo {
  4.     public static void main(String[] args) {
  5.  
  6.         /*
  7.         //6.String:字符串型，字符串需放在双引号中，0个到多个
  8.         String s1 = "Hello"; //声明字符串型变量s1并赋值为Hello
  9.         String s2 = "你好"; //声明字符串型变量s2并赋值为你好
  10.         String s3 = "我";
  11.         String s4 = ""; //声明字符串型变量s4并赋值为空字符串
  12.         //String s5 = 中国; //编译错误，必须放在双引号中
  13.         */
  14.  
  15.         /*
  16.         //5.char:字符型，字符需放在单引号中，有且仅有一个
  17.         char c1 = '女'; //声明字符型变量c1并赋值为字符女
  18.         char c2 = 'f'; //声明字符型变量c2并赋值为字符f
  19.         char c3 = '6'; //声明字符型变量c3并赋值为字符6
  20.         char c4 = ' '; //声明字符型变量c4并赋值为空格符
  21.         //char c5 = 男; //编译错误，字符必须放在单引号中
  22.         //char c6 = ''; //编译错误，必须有字符
  23.         //char c7 = '中国'; //编译错误，只能有一个字符
  24.         */
  25.  
  26.         /*
  27.         //4.boolean:布尔型，只能装true和false
  28.         boolean a = true; //声明布尔型变量a并赋值为true
  29.         boolean b = false; //声明布尔型变量b并赋值为false
  30.         //boolean c = 3.14; //编译错误，数据类型不匹配
  31.         */
  32.  
  33.         /*
  34.         //3.double:浮点型，只能装小数，很大很大很大
  35.         double a = 3.14159; //声明浮点型变量a并赋值为3.14159
  36.         double b = 25;
  37.         System.out.println(b); //25.0
  38.         */
  39.  
  40.         /*
  41.         //2.long:长整型，只能装整数，很大很大很大
  42.         long a = 250L; //声明长整型变量a并赋值为250
  43.         long b = 10000000000L; //声明长整型变量b并赋值为100亿
  44.         //long c = 3.14; //编译错误，长整型只能装整数
  45.         */
  46.  
  47.         /*
  48.         //1.int:整型，只能装整数，-21个多亿到21个多亿
  49.         int a = 250; //声明整型变量a并赋值为250
  50.         //int b = 10000000000; //编译错误，超出范围了
  51.         //int c = 3.14; //编译错误，整型只能装整数
  52.         */
  53.     }
  54. }

运算符:

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

运算符应用示例：

  1. package day03;
  2. //运算符的演示
  3. public class OperDemo {
  4.     public static void main(String[] args) {    
  5.  
  6.         /*
  7.          * 4.逻辑运算符:
  8.          *   1)&&:逻辑与(并且)，两边都为真则为真，见false则false
  9.          *     ||:逻辑或(或者)，有一边为真则为真，见true则true
  10.          *      !:逻辑非(取反)，非真则假，非假则真
  11.          *   2)逻辑运算是建立在关系运算的基础之上的，
  12.          *     逻辑运算的结果也是boolean型
  13.          */
  14.  
  15.         /*
  16.         int a=5,b=10,c=5;
  17.         boolean b2 = !(a>b);
  18.         System.out.println(b2);     //!false=true
  19.         System.out.println(!(c<b)); //!true=false
  20.         */
  21.         /*
  22.         System.out.println(a>=c || a>b); //true||false=true
  23.         System.out.println(b<=c || b>a); //false||true=true
  24.         System.out.println(a==c || b>a); //true||true=true
  25.         System.out.println(a!=c || b<c); //false||false=false
  26.         */
  27.         /*
  28.         boolean b1 = a>=c && a>b;
  29.         System.out.println(b1);          //true&&false=false
  30.         System.out.println(b<=c && b>a); //false&&true=false
  31.         System.out.println(a!=c && b<c); //false&&false=false
  32.         System.out.println(a==c && b>a); //true&&true=true
  33.         */
  34.  
  35.         /*
  36.          * 3.关系运算符:
  37.          *   1)>(大于),<(小于)
  38.          *     >=(大于或等于),<=(小于或等于)
  39.          *     ==(等于),!=(不等于)
  40.          *   2)关系运算的结果为boolean型，
  41.          *     关系成立则为true，关系不成立则为false
  42.          */
  43.         /*
  44.         int a=5,b=10,c=5;
  45.         boolean b1 = a>b;
  46.         System.out.println(b1);   //false
  47.         System.out.println(c<b);  //true
  48.         System.out.println(b>=a); //true
  49.         System.out.println(a<=c); //true
  50.         System.out.println(a==c); //true
  51.         System.out.println(a!=c); //false
  52.         */
  53.  
  54.         /*
  55.          * 2.算术运算符:+,-,*,/,%,++,--
  56.          *   1)/:两个整数相除，结果还是整数，小数位无条件舍弃
  57.          *   2)%:取模/取余，余数为0即为整除
  58.          *   3)++/--:自增1/自减1，可在变量前也可在变量后
  59.          *     3.1)单独使用时，在前在后无差别
  60.          *     3.2)被使用时，在前在后有差别
  61.          *           a++的值为a
  62.          *           ++a的值为a+1
  63.          */
  64.  
  65.         /*
  66.         int a=5,b=5;
  67.         //1)输出a++的值5
  68.         //2)a自增1变为6
  69.         System.out.println(a++); //5
  70.         System.out.println(a);   //6
  71.         //1)输出++b的值6
  72.         //2)b自增1变为6
  73.         System.out.println(++b); //6
  74.         System.out.println(b);   //6
  75.         */
  76.  
  77.         /*
  78.         int a = 5;
  79.         int b = ++a; //1)将++a的值6赋值给b  2)a自增1变为6
  80.         System.out.println(a); //6
  81.         System.out.println(b); //6
  82.         */
  83.         /*
  84.         int a = 5;
  85.         int b = a++; //1)将a++的值5赋值给b  2)a自增1变为6
  86.         System.out.println(a); //6
  87.         System.out.println(b); //5
  88.         */
  89.  
  90.         /*
  91.         int a = 5;
  92.         ++a; //相当于a=a+1
  93.         System.out.println(a); //6
  94.         */
  95.         /*
  96.         int a = 5;
  97.         a++; //相当于a=a+1
  98.         System.out.println(a); //6
  99.         */
  100.  
  101.         /*
  102.         System.out.println(5%2); //1，商2余1
  103.         System.out.println(6%2); //0，商3余0--整除
  104.         System.out.println(2%6); //2，商0余2
  105.  
  106.         System.out.println(5/2);   //2
  107.         System.out.println(6/2);   //3
  108.         System.out.println(2/6);   //0
  109.         System.out.println(5/2.0); //2.5
  110.         */
  111.  
  112.         /*
  113.         //1.赋值运算符:=
  114.         int a = 5; //声明整型变量a并赋值为5
  115.         a = a+10; //取出a的值5，加10后，再赋值给a
  116.                   //在a本身基础之上增10
  117.         System.out.println(a); //15
  118.         */
  119.     }
  120. }

 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应用示例：

  1. package day04;
  2. //if...else if结构的演示
  3. public class IfElseIfDemo {
  4.     public static void main(String[] args) {
  5.         /*
  6.          * 分支结构的练习:
  7.          * 1.完成成绩等级判断案例
  8.          * 2.完成如下三个需求:
  9.          *   需求1:满500打8折，不满500不打折
  10.          *   需求2:满500打8折，不满500打9折
  11.          *   需求3:满1000打7折，500到999打8折，不满500打9折
  12.          */
  13.  
  14.         /*
  15.         //需求3:满1000打7折，500到999打8折，不满500打9折
  16.         double price = 295.0;
  17.         if(price>=1000){
  18.             price=price*0.7;
  19.         }else if(price>=500){
  20.             price=price*0.8;
  21.         }else{
  22.             price=price*0.9;
  23.         }
  24.         System.out.println(price);
  25.         */
  26.  
  27.         /*
  28.         //需求2:满500打8折，不满500打9折
  29.         double price = 600.0;
  30.         if(price>=500){
  31.             price = price*0.8; //打8折
  32.         }else{
  33.             price = price*0.9; //打9折
  34.         }
  35.         System.out.println(price);
  36.         */
  37.  
  38.         /*
  39.         //需求1:满500打8折，不满500不打折
  40.         double price = 1000.0;
  41.         if(price>=500){ //满500
  42.             price = price*0.8; //打8折
  43.         }
  44.         System.out.println(price);
  45.         */
  46.  
  47.         /*
  48.          * 3.if...else if结构:多条路
  49.          *   1)语法:
  50.          *       if(boolean-1){
  51.          *         语句块1
  52.          *       }else if(boolean-2){
  53.          *         语句块2
  54.          *       }else if(boolean-3){
  55.          *         语句块3
  56.          *       }else{
  57.          *         语句块4
  58.          *       }
  59.          *   2)执行过程:
  60.          *       判断boolean-1，若为true则执行块1，若为false则
  61.          *       再判断boolean-2，若为true则执行块2，若为false则
  62.          *       再判断boolean-3，若为true则执行块3，若为false则执行块4
  63.          *   3)说明:
  64.          *     3.1)块1234，只可能走其中之一
  65.          *     3.2)若没有最后的else，则块123并非必走其中之一
  66.          *     3.3)若有最后的else，则块1234必走其中之一
  67.          */
  68.  
  69.         /*
  70.         int score = 45; //成绩
  71.         if(score>=90){
  72.             System.out.println("A-优秀");
  73.         }else if(score>=80){
  74.             System.out.println("B-良好");
  75.         }else if(score>=60){
  76.             System.out.println("C-中等");
  77.         }else{
  78.             System.out.println("D-不及格");
  79.         }
  80.         */
  81.     }
  82. }

 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循环应用演示：

  1. package day05;
  2. //while循环的演示
  3. public class WhileDemo {
  4.     public static void main(String[] args) {
  5.  
  6.         /*
  7.          * while的练习:
  8.          * 1.完成如下案例:
  9.          *   1)输出10次"失败是成功之母"
  10.          *   2)输出9的乘法表(正序)
  11.          *   3)输出9的乘法表(倒序)
  12.          *   4)跑3圈
  13.          *   5)打印10份简历
  14.          * 2.如上案例任选其二写执行过程
  15.          */
  16.  
  17.         /*
  18.          * 1.while结构:
  19.          *   1)语法:
  20.          *       while(boolean){
  21.          *         语句块---循环体(反复干的那个事)
  22.          *       }
  23.          *   2)执行过程:
  24.          *       判断boolean，若为true则执行语句块，
  25.          *       再判断boolean，若为true则执行语句块，
  26.          *       再判断boolean，若为true则执行语句块，
  27.          *       如此反复，直到boolean为false时循环结束
  28.          */
  29.  
  30.         /*
  31.         int num=10;
  32.         while(num>0){
  33.             System.out.println("打印一份");
  34.             num--;
  35.         }
  36.         System.out.println("over");
  37.         */
  38.  
  39.         /*
  40.         int count=0;
  41.         while(count<3){
  42.             System.out.println("跑一圈");
  43.             count++;
  44.         }
  45.         System.out.println("over");
  46.         */
  47.  
  48.         /*
  49.         int num=9;
  50.         while(num>=1){
  51.             System.out.println(num*9);
  52.             num--;
  53.         }
  54.         System.out.println("over");
  55.         */
  56.  
  57.         /*
  58.         int num=1;     //1.循环变量的初始化
  59.         while(num<=9){ //2.循环的条件
  60.             System.out.println(num*9);
  61.             num++;     //3.循环变量的改变
  62.         }
  63.         System.out.println("over");
  64.         */
  65.         /*
  66.          * 执行过程:
  67.          * num=1 true 输出9
  68.          * num=2 true 输出18
  69.          * num=3 true 输出27
  70.          * num=4 true 输出36
  71.          * num=5 true 输出45
  72.          * num=6 true 输出54
  73.          * num=7 true 输出63
  74.          * num=8 true 输出72
  75.          * num=9 true 输出81
  76.          * num=10 false while循环结束
  77.          * 输出over
  78.          */
  79.  
  80.         /*
  81.         int times=0;     //1.循环变量的初始化
  82.         while(times<10){ //2.循环的条件
  83.             System.out.println("失败是成功之母");
  84.             times++;     //3.循环变量的改变
  85.         }
  86.         System.out.println("over");
  87.         */
  88.         /*
  89.          * 执行过程:
  90.          * times=0 true 输出
  91.          * times=1 true 输出
  92.          * times=2 true 输出
  93.          * times=3 true 输出
  94.          * times=4 true 输出
  95.          * times=5 true 输出
  96.          * times=6 true 输出
  97.          * times=7 true 输出
  98.          * times=8 true 输出
  99.          * times=9 true 输出
  100.          * times=10 false while循环结束
  101.          * 输出over
  102.          */
  103.     }
  104. }

for循环应用演示：

  1. package day05;
  2. //for循环的演示
  3. public class ForDemo {
  4.     public static void main(String[] args) {
  5.         /*
  6.          * 练习:
  7.          * 1.for循环方式完成案例一和案例二
  8.          * 2.任选其一写执行过程
  9.          */
  10.  
  11.         /*
  12.         //案例二.输出9的乘法表:
  13.         for(int num=1;num<=9;num++){
  14.             System.out.println(num*9);
  15.         }
  16.         System.out.println("over");
  17.         */
  18.         /*
  19.         //案例一.输出10次"失败是成功之母":
  20.         for(int count=0;count<10;count++){
  21.             System.out.println("失败是成功之母");
  22.         }
  23.         System.out.println("over");
  24.         */
  25.         /*
  26.          * 执行过程:
  27.          * count=0 true 输出
  28.          * count=1 true 输出
  29.          * count=2 true 输出
  30.          * count=3 true 输出
  31.          * count=4 true 输出
  32.          * count=5 true 输出
  33.          * count=6 true 输出
  34.          * count=7 true 输出
  35.          * count=8 true 输出
  36.          * count=9 true 输出
  37.          * count=10 false for循环结束
  38.          */
  39.  
  40.     }
  41. }

基础-训练营-day1~day5的更多相关文章

  1. go基础编程 day-1

    Go语言的特性 开启了学习新的语言路程,记录每天学习的笔记,与大家一起分享. ①.自动垃圾回收 ②.更丰富的内置类型 ③.函数多返回值 ④.错误处理 ⑤.匿名函数和闭包 ⑥.类型和接口 ⑦.并发编程 ...

  2. 9-Python基础知识-day1

    Python基础知识-day1 Python 2 和Python 3 的区别: Python2 源码不标准,混乱,重复代码多:#-*-encoding:utf8 -*- 解决python2显示中文的问 ...

  3. 【算法训练营day1】LeetCode704. 二分查找 LeetCode27. 移除元素

    [算法训练营day1]LeetCode704. 二分查找 LeetCode27. 移除元素 LeetCode704. 二分查找 题目链接:704. 二分查找 初次尝试 看到题目标题是二分查找,所以尝试 ...

  4. python基础之day1

    Python 简介 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言. Python为我们提供了非常完善的基础代码库,覆盖了 ...

  5. python基础篇-day1

    python基础篇 python是由C语言写的: pass 占位符: del,python中全局的功能,删除内存中的数据: 变量赋值的方法: user,pass = 'freddy','freddy1 ...

  6. C++基础知识－Day5

    今天主要讲的是类的扩展 1.类成员函数的存储方式 首先我们介绍类成员函数的存储方式,C++引入面向对象的概念之后,C语言中的一些比如static/const等原有语义,作一些升级,此时既要保持兼容,还 ...

  7. Linux基础系列-Day1

    Linux发展简史 Unix:1969年由美国电话电报公司(AT&T)贝尔实验室的两个工程师所创造的操作系统,它允许计算机同时处理多用户和程序. BSD:重要的Unix分支,1977年由加州大 ...

  8. python基础训练营01

    一.基础讲解: 1.1 文件末尾的.py后缀,指出这个文件,是一个python文件,因此,系统将使用python解释器来运行该文件,确定文件中每一个单词的含义. 1.2 python编辑/运行方法: ...

  9. ECS7天实践进阶训练营Day1：使用阿里云ECS，快速搭建、管理VuePress静态网站

    一.概述 VuePress是2018年由尤雨溪发布的一个全新的基于Vue的静态网站生成器,它是一个非常轻量级的静态网站生成器.VuePress主要用于生成技术文档,其类似于Gitbook,我们可以用于 ...

随机推荐

  1. JS倒计时代码

    第一种:精确到秒的javascript倒计时代码 HTML代码: <form name="form1"> <div align="center" ...

  2. mysql5.6 通用二进制安装

    mysql5.6 通用二进制安装: #卸载原有的mysqlyum remove mysql*ls /etc/my.cnf*mv /etc/my.cnf* /tmp/ #安装依赖包yum install ...

  3. easyui datagrid 列显示和隐藏

    //当查询IT基础设施的时候隐藏'STAFF_ID'.'ITSM_STAFF_ID' if($("input[name='currentstate']").val()==2){ $ ...

  4. 记在thinkPHP中一个创建模型的小错误

    在创建好模型以后,访问说没有该方法,如图 看代码 class ManagerModel { //put your code here function checkDenglu($name,$pwd){ ...

  5. Ubuntu输入密码登陆后又跳回到登录界面

    现象:在Ubuntu登陆界面输入密码之后,黑屏一闪并且出现了check battery state之类的文字之后,又跳转到登录界面.原因:主目录下的.Xauthority文件拥有者变成了root,从而 ...

  6. CSS系列：less备忘

    less备忘 //这是一个运行在koala中的less文件,//注释不会被编译到css文件中,/**/注释会 ****************by 李可 2016/04/19 /*所有,所有伪类*/ ...

  7. FZU 2195 思维

    很无聊的背景故事...求最短的时间原来就是省去了检查员最后上山的时间...还让不让人回家了... 感觉这是个最短路 思想是求出来dis 然后求里面最大的那条边 用总长减去最长边 就是答案 写了一个小时 ...

  8. [办公自动化]windows7 仿宋GB2312字体打印不对

    今天同事发现自己的文档中,仿宋GB2312这种字体打印的看着总觉得不对. 他使用的操作系统是windows7,office 是2007. 解决方案: 将windows xp中的c:\windows\f ...

  9. 一些站点使用的服务器软件、js 框架大收集 [ 整理中 ]

    Chrome 的扩展应用 ChromeSnifferPlus ( 开源中国地址:http://www.oschina.net/p/chromesnifferplus,GitHub 地址:https:/ ...

  10. spring mvc和spring配置扫描包问题

    spring mvc和spring俩配置文件,其中都要配置扫描包. <context:component-scan base-package="com.controller" ...