• Java基础（一文读懂Java基础）

    目录

    一：基础语法

    “Hello word”

    Java的运行机制

     Java基本语法

    1.注释、标识符、关键字

    2.数据类型（四类八种）

    类型转换

    1.自动转换

     2.强制转换

    常量和变量

    1.常量

    2.变量

    3.变量的作用域

    运算符

    1.算数运算符

    2.赋值运算符

    3.关系运算符

    4.逻辑运算符

    5.自增、自减运算符

    二：Scanner与流程控制：

    Scanner用法

    流程控制

    1.顺序结构

    if选择结构

    1.单if语句

    2.标准语句

    3.扩展语句

    switch选择结构

    1.break关键字

    2.default关键字

    3.continue关键字

    循环结构

    1.while循环

    2.do while循环

    3.for循环（重点）

    4. 增强for

    三：方法的定义和调用

    一：基础语法

    “Hello word”

    1.首先下新建一个文件夹存放代码，

    2.新建一个Java文件来存放Java的相关代码。

    注意点：文件的后缀名为Java（本文为Hellow.java）

    1. public class Hello {
    2.  
    3. //class后面的名字应该和文件名保持一致，否则会报错
    4.  
    5.   public static void main(String[] args){
    6.  
    7.      System.out.print("Hello Word");
    8. //System.out.print("XXX")打印输出语句
    9.  
    10.   }
    11.  
    12. }

    在cmd的根目录i下进行执行的时候采用javac Hellow.java 来执行文件会生成一个class文件，接着执行java Hellow来执行编译文件就会自动的打印输出Hello word！。

    Java的运行机制

    1.编译型：直接编译成系统可以理解的语言。这样的执行速度会更快。

    2.解释型：把机器不懂的地方进行解释从而来进行执行。

    Java编译器将准备好的源文件编译成了class文件，真正被执行的应该是class文件。此时将class文件放入到类加载器，放在Jvm中进行。字节码校验器来进行代码的校验，校验完成若没有了错误，此时的解释器便开始工作将我们的程序解释给操作系统从而进行解读。

     Java基本语法

    1.注释、标识符、关键字

    注释（以代码为例）：

    1. public class HelloWord {
    2.     public static void main (String[] args){
    3.         //单行注释：只能注释一行内容
    4.         //输出一个HelloWord
    5.         System.out.println("Hello Word!");
    6.         /*为多行注释：可以注释多行内容*/
    7.         /*System.out.println("Hello Word1!");
    8.         System.out.println("Hello Word2!");
    9.          */
    10.         //JavDdoc文档注释
    11.         /**文档注释：可以加功能
    12.          * @Author 代码贩子、 --南京邮电大学
    13.          */
    14.     }
    15. }
    （标识符）：Java中所有的组成部分都需要名字。类名，变量名，以及方法名都称之为标识符。

    注意点：所有的标识符都应该以（A——z）、$、或者是下划线开始的。

                  首字符之后可以是（A——z）、$、或者是下划线的组合。

                  关键字不可以作为名字。

    可以是中文名字但是一般不采用，因为太Low，会被同行看不起。

    标识符是大小写敏感的。

    2.数据类型（四类八种）

    Java为一款强类型的语言，所有变量的使用必须严格的符合固定，所有的变量只有被定义后才能进行使用。

    类型转换

    重点提示：（有人问为什么long占的字节比float的多还排在float后面？因为在发生转换的时候小数的优先级要大于整数。）不同类型的数据结构先转化为同一类型的，然后再进行计算。

    强制转换分为两种，一种是从低到高的转换方法，一种是从高到低的转换方法。

    1.自动转换

    显式（规则：数据范围从低到高）：代码不需要进行处理并且直接可以完成转换。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class HelloWord {
    5.     public static void main (String[] args){
    6.         //直接输出一个整数，默认是int型
    7.         System.out.println("30");
    8.         //直接输出一个小数，默认是double型
    9.         System.out.println("3.12");
    10.         //（1）左边是long类型，右边是int类型
    11.         //（2）=进行赋值，右边默认给左边 int——>long满足从低到高的转换规则
    12.         //（3）这一行代码发生了自动转换
    13.        long name1=100;
    14.        System.out.println(name1);
    15.        //(1)右边是float类型，左边是double类型
    16.        //（2）float->double，满足从低到高的转换规则
    17.       //（3）所以发生了自动转换
    18.        double name2=3.1415926F;
    19.        System.out.println(name2);
    20.        //(1)右边是long类型，左边是float类型
    21.        //（2）long->float,满足从低到高的转换规则
    22.        //（3）所以发生了自动转换
    23.        float name3=30L;
    24.        System.out.println(name3);
    25.     }
    26. }

     2.强制转换

    代码需要进行处理不能够自动的完成转换。

    格式：（范围小的类型）+范围小的变量名=（范围小的类型）+原本范围大的数据

    注意：（1）在进行前置转换的时候可能会出现内存溢出、精度丢失等现象。

               （2）byte/short/char这三种类型可以进行数学计算。

               （3）byte/short/cha这三种类型在进行运算的时候首先会被默认为是int卡类型。

               （4）布尔类型不可以进行任何的数据转换。
     

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class HelloWord {
    5.     public static void main (String[] args){
    6.         //（1）右边是long类型，左边是int类型
    7.         //（2）long->int 不是从高到低，所以需要进行强制转换
    8.         //（3）格式：（较小的数据类型）+较小的变量名=（较小的数据类型）+（原本范围较大的数据）
    9.         int nume1 = (int) 100L;
    10.         System.out.println(nume1);
    11.         //（1）右边是int类型，左边是int类型
    12.         //（2）int->byte
    13.         //（3）格式：（较小的数据类型）+较小的变量名=（较小的数据类型）+（原本范围较大的数据）
    14.         //写法一：
    15.         int a = 200;
    16.         byte b = (byte) a;
    17.         //写法二：
    18.         byte nume2 = (byte) 200;
    19.         //输出值为-56
    20.         //原因为200超过了byte的数据范围，发生了内存溢出的现象，所以在发生强制转换之后的输出值为负数。
    21.         System.out.println(b);
    22.         System.out.println(nume2);
    23.         float c = 3.14f;
    24.         int d = (int) c;
    25.         //此时的输出值为3
    26.         //因为在强制转换的时候float->int会发生精度丢失的问题，所以最后的输出值为3而不是3.14。
    27.         System.out.println(d);
    28.         //输出的值为97
    29.         char e ='a';
    30.         int f= (int)e;
    31.         System.out.println(f);
    32.         //输出的值为b
    33.          int g= f+1;
    34.         System.out.println((char) g);
    35.         //应该是20000000000，但是实际的结果输出的为一个负数
    36.         //那是因为计算的时候溢出了
    37.         int moeny = 10_0000_0000;
    38.         int years = 20;
    39.         int total = moeny*years;
    40.         System.out.println(total);
    41.         //虽然发生了自动转换还是输出的为负数
    42.         //因为默认是int并且在转换之前就已经出现了问题。
    43.         long total2 = total;
    44.         System.out.println(total2);
    45.         //此时输出的结果为正确的数值
    46.         //输出的结果为20000000000
    47.         //解决方法：先把一个数据转化为long类型
    48.         long total3 = moeny*(long)years;
    49.         System.out.println(total3);
    50.     }
    51. }

    常量和变量

    1.常量

    定义：在程序运行期间固定不变的量

    格式：final 常量名 = 值；

              final double PI = 3.1415926；

     常量的分类：

     （1）字符串常量：凡是用双引号引起来的量：如“ABC” "Hellow" "123"

      （2）整数常量：无小数点的数字：如1 -100  0

      （3）浮点型：直接写上的数字，有小数点：如2.5 -3.14 0.0

      （4）字符常量：凡是用单引号引起来的单个字符：如‘A’ ‘b’ '1' '中'

      （5）布尔常量：只有量中取值：如 true false

      （6）空常量：null 代表没有任何的数组

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class HelloWord {
    5.     public static void main (String[] args){
    6.         //字符型常量
    7.         System.out.println("kj10");
    8.         System.out.println("");//两个双引号之间的内容为空，也有打印输出
    9.         System.out.println("ABC");
    10.         //整数常量（整数）
    11.         System.out.println(-400);
    12.         System.out.println(0);
    13.         //浮点型（小数）
    14.         System.out.println(3.14);
    15.         System.out.println(-0.25);
    16.         //字符常量
    17.         System.out.println('帅');
    18.       //  System.out.println('AB');
    19.        // System.out.println('');//字符常量有且仅有一个字符，不能有两个，也不能为空
    20.         //布尔常量
    21.         System.out.println(true);
    22.         System.out.println(false);
    23.         //空常量
    24.        // System.out.println(null);//空常量不能直接打印输出
    25.         System.out.println();//或者什么都不写可以进行打印输出
    26.     }
    27. }

    2.变量

    定义：可以随时发生变化的量，也是Java程序中最基本的储存单元，其要素包括变量名，变量类型和作用域。

    注意点：（1）每个变量都有类型，类可以是基本类型也可以是引用类型。

                  （2）变量名必须是合法的标识符。

                  （3）变量声明的是一个完整的语句，所以每一个声明必须都要以分号结束。

                  （4）修饰符不存在前后的顺序，可以是 final static double PI = 3.1415926；也可以是 static final double PI = 3.1415926；

    格式;数据类型 + 变量名 = 值；（可以用逗号隔开来来声明多个同类型的变量）。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class HelloWord {
    5.     public static void main (String[] args){
    6.         //写法一:
    7.         //为了方便程序的可读性，所以不建议这么写
    8.         int a=1,b=2,c=3;
    9.         //写法二（推荐写法）：
    10.         int d = 1;
    11.         int e = 2;
    12.         int f = 1;
    13.     }
    14. }

    3.变量的作用域

    （1）类变量：写在类里面的变量，加上satatic的关键字。

    （2）实例变量：写在方法的外面，类的里面（从属于对象，或者理解为从属于这个类，要通过这个类来使用它，如果不规定初始值则利用的是初始值）并且不需要进行初始化。

    （3）局部变量：写在方法里面的变量（包括写在主程序里面的方法），必须声明和初始化值。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class HelloWord {
    5.     //类变量：加上关键字static
    6.     //类变量是从水属于这个类的，会随着这个类一起出来和消失。
    7.     static double saLary = 2500;
    8.     //实例变量：写在方法的外面，类得 里面。从属于对象或者是从属于这个类，要通过这个类才能使用它，可以不设置初始值
    9.     String name;
    10.     int age;
    11.     //主程序的方法或者是叫mian方法
    12.     public static void main (String[] args){
    13.         //局部变量是写在方法里面的，只对这个方法负责，跳出方法之外就不能被使用
    14.         //所有的局部变量必须声明和设置初始值
    15.         int i = 10;
    16.         System.out.println(i);
    17.         //使用面向对象的范畴
    18.         //左边的HelloWord为自定义类型，helloWord为引用类型
    19.         //变量类型+变量名字=值为new 变量HelloWord（）；将相当于拿到了自己，也就是把自己给自己才能拿到自己的实例变量
    20.         //如果实例化对象不给初始值，则会默认输出默认初始化的数值。
    21.        HelloWord helloWord= new HelloWord();
    22.        System.out.println(helloWord.name);
    23.        System.out.println(helloWord.age);
    24.        //类变量：加上关键字static
    25.         //如果去点static则不会被调用
    26.         System.out.println(saLary);
    27.     }
    28.     //新写的一个增加的方法
    29.     public void add(){
    30.         //这里不能说输出变量i是因为局部变量不在add的方法里面。
    31.         System.out.println(i);
    32.       HelloWord helloWord= new HelloWord();
    33.       //这里的add方法可以调用实例变量，是因为add方法在实例变量的作用域内
    34.       System.out.println(helloWord.name);
    35.       System.out.println(helloWord.age);
    36.       //这里的add方法也作用在类变量的作用域内，所以可以调用类变量
    37.       System.out.println(saLary);
    38.     }
    39. }

    运算符

    1.算数运算符

    算数运算符：+、-、*、/、%（取余）

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class HelloWord {
    5.     public static void main (String[] args){
    6.         long a = 3000000000000000000L;
    7.         int b = 20;
    8.         double c = 3.14;
    9.         int d = 10;
    10.         //因为有double类型的，所以输出为double类型
    11.         System.out.println(a+b+c+d);
    12.         //输出的为3000000000000000020，明显超出了int类型，因为有long类型，这里发生了自动转换，默认为龙类型
    13.         System.out.println(a+b);
    14.     }
    15. }

    2.赋值运算符

    赋值运算符：=

    赋值运算符：=、+=、-+、*+、/=、%=

    （1）+=    a +=3    相当于     a=a+3
    （2）-=    a -=3    相当于     a=a-3
    （3）*=    a *=3    相当于     a=a*3
    （4）/=    a /=3    相当于     a=a/3
    （5）%=    a %=3    相当于     a=a%3

    注意事项：只有变量才能使用赋值运算符

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4. public class fx{
    5.     public static void main(String[] args){
    6.         int a=10;
    7.         a+=5;
    8.         System.out.println(a);//15
    9.     }
    10. }

    3.关系运算符

    关系运算符:>、<、>=、<=、==(相等)、!=(不等)

    注意：（1）比较运算符的结果必须是个布尔型，成了为ture，不成立为false
               （2）如果进行多次判断不可以连着写 例如1

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main(String[] args){
    5.         int a=10;
    6.         int b=20;
    7.         int c=20;
    8.         System.out.println(a>b);//false
    9.         System.out.println(a//true
    10.         System.out.println(a>=b);//flase
    11.         System.out.println(a<=b);//true
    12.         System.out.println(a==b);//false
    13.         System.out.println(a!=b);//ture
    14.         System.out.println(b==c);//true
    15.     }
    16.

    4.逻辑运算符

    逻辑运算符：&&(与)、||(或)、！(非)

    注意：（1）“&&和||”同时使用的时候会出现短路的情况，如果左边已经得到了结果，那么右面的将不再执行。

               （2）“&&和||”左右各需要一个布尔型。但是取反只需要一个布尔型即可。

               （3）“&&和||”如果有多个条件可以进行连写。

                  两个条件：条件A&&条件B

                 三个条件：条件A&&条件B&&条件C

    对于1 

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main(String[] args){
    5.         System.out.println(true&&false);//false
    6.         System.out.println(true&&true);//true
    7.         System.out.println(3<5&&5<6);//true
    8.         System.out.println(true||true);//true
    9.         System.out.println(true&&false);//true
    10.         System.out.println(false&&false);//false
    11.         System.out.println(true);//true
    12.         System.out.println(!true);//false
    13.         //短路
    14.         int a=10;
    15.         System.out.println(3>4&&++a<20);//true   左边已经可以判断得到最终结果，右边将不在执行
    16.         System.out.println(a);//10
    17.         int b=20;
    18.         System.out.println(3<4||++b<30);//true   左边已经可以判断得到最终结果，右边将不在执行
    19.         System.out.println(b);//20
    20.     }

    5.自增、自减运算符

    ++、--

    基本含义：让变量上升或者是下降一个为1的值。

    注意：在单独使用的时候++a和a--没有什么区别。

              在混合使用的时候：前++为先加后用。变量+1然后拿着加上的值继续使用。

                                              后++为变量直接使用，然后在加上1。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */   
    4.      public static void main (String[] args){
    5.         int a = 10;
    6.         int b = ++a;
    7.         //如果不写++a，那么输出的a的值为10；加上的话输出的值为11，因为++a为先加后用。
    8.         System.out.println(a);//11
    9.         System.out.println(b);//11
    10.         int c = a++;
    11.         //先用后加
    12.         System.out.println(c);
    13.     }

    二：Scanner与流程控制：

    Scanner用法

              第一步：导入sacnner类   import Java.until.*;(写在公共类的来头）

             第二步：创建Scanner对象 Sacnner scanner=new Scanner（system.in);//构造Scanner类的对象sc,接收从控制台输入的信息

             第三步：打印输出提示符号 System.out.println（"提示文字）；

             第四步：获取键盘输入的数据  String src=input.nextlnt()/nextLine();

             第五步：打印输出值：System.out.println("打印输出的值为:");

             第六步：hasNext()/hasnextLine()来判断是否还有下一个输入。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         //new Scanner()为创建一个Scanner对象，或者说是创建一个Scanner扫描器；
    6.         //System.in用来接收键入的数据
    7.         Scanner scanner = new Scanner(System.in);
    8.         //提示输入的数据
    9.         System.out.println("请输入数据：");
    10.         //等待你所有的输出，将字符串的额变量全部保存在变量中最后在通过下一句进行输出。
    11.         String src = scanner.next();
    12.         //用来提示输出数据
    13.         //这里在输出带有空格的字符串会出现空格之后的不输出，因为next()不能得到带有空格的字符串。
    14.         System.out.println("您输出的数据为："+src);
    15.         //如果使用的是nextLine()来进行接收，就可以获得空格之后的所有字符。因为nextLine()是以Enter为结束符，nextLine()方法返回的是输入回车之前的所有字符。
    16.         String src2 = scanner.nextLine();
    17.         System.out.println("您输出的数据为："+src2);
    18.         //I/O流来进行关闭，减少所占用的资源。
    19.         scanner.close();
    20.     }
    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         //new Scanner()为创建一个Scanner对象，或者说是创建一个Scanner扫描器；
    6.         //System.in用来接收键入的数据
    7.         Scanner scanner = new Scanner(System.in);
    8.         System.out.println("请输入数据：");
    9.         //if语句来进行是否还有数据的输入
    10.         //scanner.hasNext()，看一下这个对象还有没有下一个。
    11.         if(scanner.hasNext()){
    12.             //通过scanner来接收用户的数据。
    13.             String src = scanner.nextLine();
    14.             //输入的内容为src的字符串
    15.             System.out.println("您输出的信息为"+src);
    16.         }
    17.         //I/O流关闭资源
    18.         scanner.close();
    19.     }


     

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         int a = 10;
    6.         float b = 3.14f;
    7.         Scanner scanner = new Scanner(System.in);
    8.         System.out.println("请输入一个整数：");
    9.         if(scanner.hasNextInt()){
    10.             a = scanner.nextInt();
    11.             System.out.println("您输入的整数值为："+a);
    12.         }else{
    13.             System.out.println("您输入的不是整数！");
    14.         }
    15.         System.out.println("请输入一个小数：");
    16.         if(scanner.hasNextFloat()){
    17.             b = scanner.nextFloat();
    18.             System.out.println("您输入的小数值为："+b);
    19.         }else{
    20.             System.out.println("您输入的不是小数！");
    21.         }
    22.         scanner.close();
    23.     }

    练习：键入多个数字，求输入数字的平均值以及总和。在输入数值的时候需要通过回车键来进行确认，并且通过非数值来结束，结束时输出对应的总和以及平均数的计算结果。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         //首先定义两个数值，sum以及输入的次数。
    6.         double sum = 0;//定义初始值为0的总和sun
    7.         int m = 0;//定义输入的次数m
    8.         //创建扫描器
    9.         Scanner scanner = new Scanner(System.in);
    10.         System.out.println("请输入一个数：");
    11.         //判断是否还有数据的输入
    12.         while (scanner.hasNextDouble()){
    13.             //输入一个随机数值
    14.            double x = scanner.nextDouble();
    15.             //输入了m+1次
    16.             m++;//m=m+1
    17.             //每次输入的数值相加，最后赋值给sum
    18.             sum = sum+x;
    19.             System.out.println("你输入了"+m+"次数值，当前的和为"+sum);
    20.         }
    21.         System.out.println("前"+m+"次的总和为"+sum);
    22.         System.out.println("输入"+m+"次之后的平均值为"+sum/m);
    23.         scanner.close();
    24.     }

    流程控制

    1.顺序结构

    定义：Java的基本结构就是顺序结构，除非特殊指明，否则就按照顺序一步一步的执行。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main(String[] args){
    5.         System.out.println("今天天气不错");
    6.         System.out.println("拿了十块钱");
    7.         System.out.println("去网吧打撸啊撸");
    8.     }

    if选择结构

    1.单if语句

     if(关系表达式<或者是布尔表达式>){  
        语句体（true就成立执行语句体，false就绕过了语句体，直接输出结束。）；
    }

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         Scanner scanner = new Scanner(System.in);
    6.         String str = scanner.nextLine();
    7.         //str.equals("hello"判断是否为真
    8.         if (str.equals("hello")){
    9.             System.out.println(str);
    10.         }
    11.         System.out.println("End");
    12.         scanner.close();
    13.     }

    2.标准语句

    if（关系表达式）{

    语句体1；

    }else{

    语句体2；

    }

    注意：如果关系表达式为ture则执行语句体1，如果表达式为false则执行语句体2。

               在执行的时候不能两个都执行，也不能两个都不执行。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         Scanner scanner = new Scanner(System.in);
    6.         System.out.println("请输入您要验证的成绩:");
    7.         double score = scanner.nextDouble();
    8.         if (score>=60){
    9.             System.out.println("您的成绩合格！");
    10.         }else{
    11.             System.out.println("您的成绩不合格！");
    12.         }
    13.         scanner.close();
    14.     }

    3.扩展语句

    if（判断条件1）{

    语句体1；

    }else if（判断条件2）{

    语句体2；

    }

    ...........

    else if（判断条件n）{

    语句体n；

    }else{

    语句体n+1；

    }

    注意：如果满足条件一，则下下面的将不再执行，如果为false则执行语句体2、3、n。有一个满足的下面的将不再执行。

              如果以上的都不满足，将会无条件的执行else里的n+1的条件语句。

    小练习：输入指定的考试成绩，判断考试的等级：1.90-100 优秀；2.80-89  良；3.70-79  中；4.60-69  合格；5.0-59   差。

    1.  /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         Scanner scanner = new Scanner(System.in);
    6.         System.out.println("请输入您要验证的成绩:");
    7.         double score = scanner.nextDouble();
    8.         if (score>=90&&score<=100){
    9.             System.out.println("您的成绩为优秀，请保持状态！");
    10.         } else if (score>=80&&score<=89){
    11.             System.out.println("您的成绩为良，还有提升的空间！");
    12.         } else if (score>=70&&score<=79){
    13.             System.out.println("您的成绩为中等，你还可以更进一步！");
    14.         }  else if (score>=60&&score<=69){
    15.             System.out.println("您的成绩为合格，请继续努力！");
    16.         }else if (score>=0&&score<59){
    17.             System.out.println("您的成绩不合格，请加倍努力！");
    18.         }else{
    19.             System.out.println("您的输入有误，请重新输入！");
    20.         }
    21.         scanner.close();
    22.     }

    switch选择结构

    1.break关键字

    break关键字可以用在switch中，一旦执行，整个switch将立刻结束。
    break关键字也可以用在其他语句中，整个循环语句立刻结束，打断循环。

    2.default关键字

    default的作用是在case匹配失败之后才会被执行，打印出来相对应的输出信息。

    3.continue关键字

    contine关键字立即跳过本次的循环，进入到下一个循环语句当中。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         char grade = 'c';
    6.         //switch匹配一个值比较方便
    7.         switch (grade){
    8.             case 'a':
    9.             System.out.println("优");
    10.             break;
    11.             case 'b':
    12.                 System.out.println("良");
    13.                 break;
    14.             //break在整个语句中，一旦被执行将会结束整个循环。
    15.             //如果不加break将会出现贯穿的现象。
    16.             //c和d如果不加break将会打印输出“中”后面的所有的输出字符。
    17.             case 'c':
    18.                 System.out.println("中");
    19.                 break;
    20.             case 'd':
    21.                 System.out.println("差");
    22.                 break;
    23.             //default的作用是在case匹配失败之后才会被执行，打印出来相对应的输出信息。
    24.             default:
    25.                 System.out.println("您的输入有误！");
    26.         }
    27.     }

    循环结构

    循环结构表

    顺序上

    应用上

    格式

    For循环

    先判断。在执行。

    循环次数确定，通常用for循环。

    for（初始化表达式；条件判断；步进语句）{

          循环体

    }

    While循环

    先判断。在执行。

    循环次数不确定，通常用whiler循环。

    初始表达式；

    While（条件判断）{

    循环体

    步进语句

    }

    Do  whlle循环

    先执行，在判断

    循环次数不确定，通常用whiler循环。

    初始表达式；

    Do{

    循环体

    步进语句

    }while（条件判断）；

    1.while循环

    在进行执行的时候首先对条件语句进行判断才进行执行，在循环次数不确定的时候通常使用while循环语句。

    初始表达式；

    while（条件判断）{

    循环语句；

    步进语句；

    }

    小练习：使用whlle循环语句来计算1+2+3+……+100的和。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         int i = 0;
    6.         int sum = 0;
    7.         while (i<=100){
    8.             sum = sum + i;
    9.             i++;
    10.             System.out.println("此时运行了：" + i+"次，" + "此时的和为"+sum);
    11.         }
    12.         System.out.println("和为：" +sum);
    13.     }

    2.do while循环

    在执行的时候首先执行才能进行判断，即使不能满足条件也至少执行一次。循环次数不确定，通常用whiler循环。

    初始语句；

    do{

    循环体；

    步进语句；

    }while（条件判断表达式）；

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         int i = 0;
    6.         int sum = 0;
    7.        do {
    8.                sum = sum + i;
    9.                i++;
    10.                System.out.println("此时运行了：" + i+"次，" + "此时的和为"+sum);
    11.            } while (i<=100);
    12.         System.out.println("和为：" +sum);
    13.     }

    3.for循环（重点）

    在执行的时候先进性判断然后在执行，在执行的时候循环次数确定。

    for（初始值；条件表达式；步进语句）{

    循环体1；

    }else{

    循环体2；

    }

    小练习1：求100以内（包括100）的奇数偶数的和以及总体的和。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         int sum1 = 0;
    6.         int sum2 = 0;
    7.         for (int i = 0; i <=100 ; i++) {
    8.             if (i%2!=0){
    9.                 sum1+=i;
    10.             }else{
    11.                 sum2+=i;
    12.             }
    13.             System.out.println("此时的和为："+sum1);
    14.             System.out.println("此时的和为："+sum2);
    15.         }
    16.         System.out.println("此时的和为："+sum1+sum2);
    17.     }

    小练习2：用for循环输出1-1000以内（包含1000）内所有可以被5整除的数，并且每一行只打印三个。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         for (int i = 0; i <=1000 ; i++) {
    6.             //这里说明是可以被5整除的数，我们把它输出出来
    7.             if (i%5==0){
    8.                 System.out.print("您得到的数为："+i+"\t");
    9.             }
    10.             //如果i模5*3。那么就是先换行
    11.             if (i%(5*3)==0){
    12.                 System.out.print("您得到的数为："+"\n");
    13.             }
    14.         }
    15.     }

    3.小练习：打印等腰三角形

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         for (int i = 1; i <= 5; i++) {
    6.             for(int j = 5;j >= i;j--){
    7.                 System.out.print(" ");
    8.             }
    9.             for (int j = 1;j <= i;j++){
    10.                 System.out.print("*");
    11.             }
    12.             for (int j = 1;j < i;j++) {
    13.                 System.out.print("*");
    14.             }
    15.             System.out.println();
    16.         }
    17.     }

    4.小练习：利用for循环打印九九乘法表。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         //3.加入for循环之后将常量1都替换成变量j。下面需要去掉重读的项目。找一下是哪里写死的原因
    6.         //4.此时发现缺2*9 3*9 4*9......
    7.         //5.此时只要减少重复项即可，我们发现j是不变的，只有i
    8.         for (int j =1;j<=9;j++){
    9.             //1.先打印第一列
    10.             for (int i = 1; i <=j; i++) {
    11.                 //2.输出成1*i的形式，此时应该考虑怎么解决2* 3*的问题，如果解决的话需要将常量1改成变量的形式，在佳茹一个for循环
    12.                 System.out.print(j+"*"+i+"="+(j*i)+"\t");
    13.             }
    14.             //每输出一行进行换行
    15.             System.out.println( );
    16.         }
    17.     }

    4. 增强for

    主要用来遍历数组和集合的。

    for（声明语句：表达式）{

    代码句子；

    }

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         int[] i ={10,20,30,40,50};
    6.         //上下相等，这里是数组部分，目前可以不做讨论。
    7.         for(int x =0;x<5;x++){
    8.             System.out.println(i[x]);
    9.         }
    10.         //数组每一项遍历出来赋值给int x，x指的就是每一个数值
    11.         for (int x:i){
    12.             System.out.println(x);
    13.         }
    14.     }

    三：方法的定义和调用

    1.方法的定义：方法包括一个方法的开头和一个方法体。

    修饰符 返回值类型 方法名（参数类型 参数名）{

    方法体；

    return 返回值；

    }

    解释：

    修饰符可以有 public static final等

    返回值类型如果为void则返回为空，也就是不需要rutern，如果是int等类型需要进行返回，

    方法名可以根据命名的规则来自己进行定义，比如增加的add方法和删除的del方法。

    参数类型包括两种，一个形式参数和一个实际参数。参数像是一个占位符，可以被选择，也可以不做选择（也就是方法可以 不含参数）。

    ***形式参数指的是在方法被调用时来接收外界输入的数据。

    ***实际参数指的是调用方法实际传给对方的参数。

    方法体：包括定义的具体语句以及定义该方法的功能。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         //直接调用方法，给个实际参数1和2。
    6.         /*
    7.         上面的参数1和2传输给下面的a和b，经过reyurn传给sum进行输出。
    8.         也就是通过这个语句来调用这个方法。
    9.          */
    10.         int sum = add(1,2);
    11.         System.out.println(sum);
    12.     }
    13.     //写一个add的方法，给个形式参数a和b，想要被main方法调用，需要用修饰符static改成类方法
    14.     //这里的加法需要定义函数，使用形参的形式
    15.     public static int add (int a,int b) {
    16.         //返回一个值，如果是void则不需要进行返回，如果是int等则需要进行返回并且一一的对应。
    17.         return a + b;
    18.     }

    2.方法的调用：

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args) {
    5.         //这里的maxmin作为有参的结果赋给max这个值在进行打印输出。
    6.         int max =maxmin(30,30);
    7.         //这里的方法没有返回值，只用来传递参数来进行输出。
    8.         System.out.println(max);
    9.     }
    10.     public static int maxmin(int a,int b){
    11.         int result=0;
    12.         if(a==b){
    13.             System.out.println("a=b");
    14.             return 0;//终止方法
    15.         }
    16.         if (a>b){
    17.              result=a;
    18.         }else{
    19.             result=b;
    20.         }
    21.         return result;
    22.     }

    例如：int max =maxmin(30,30);

    如果方法为void，方法的调用一定是一条语句。

    例如：System.out.println("Hello word");

    小练习：调用方法打印正三角形。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args){
    5.         test();
    6.     }
    7.     public static void test(){
    8.         for (int i = 1; i <= 5; i++) {
    9.             for(int j = 5;j >= i;j--){
    10.                 System.out.print(" ");
    11.             }
    12.             for (int j = 1;j <= i;j++){
    13.                 System.out.print("*");
    14.             }
    15.             for (int j = 1;j < i;j++) {
    16.                 System.out.print("*");
    17.             }
    18.             System.out.println();
    19.         }
    20.     }

    2.方法重载

    简单的说就是方法名称相同，方法里面包含的参数类型不同。

    方法重载的规则：

    1.方法名必须相同。

    2.参数名称必须不同。（个数不同，类型不同，排列顺序不同等。）

    3.方法的返回值可以相同也可以不同。

    4.仅仅是返回值类型不同则不可以完成方法的重载。

    实现理论：方法名称相同的时候，编译器会根据方法参数类型的个数，参数类型去逐个匹配，以选择对应的方法，如果匹配失败，编译器会报错。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     public static void main (String[] args) {
    5.         //这里的maxmin作为有参的结果赋给max这个值在进行打印输出。
    6.         double max =maxmin(30.0,20.0);
    7.         //这里的方法没有返回值，只用来传递参数来进行输出。
    8.         System.out.println(max);
    9.     }
    10.     public static double maxmin(double a,double b){
    11.         int result=0;
    12.         if(a==b){
    13.             System.out.println("a=b");
    14.             return 0;//终止方法
    15.         }
    16.         if (a>b){
    17.             //这里从高到低需要进行强转
    18.             result=(int) a;
    19.         }else{
    20.             result=(int) b;
    21.         }
    22.         return result;
    23.     }
    24.     public static int maxmin(int a,int b){
    25.         int result=0;
    26.         if(a==b){
    27.             System.out.println("a=b");
    28.             return 0;//终止方法
    29.         }
    30.         if (a>b){
    31.              result=a;
    32.         }else{
    33.             result=b;
    34.         }
    35.         return result;
    36.     }

  • 相关阅读:
    Android程序设计之音乐播放器实现
    0-1背包问题
    CentOS7 离线安装 Python
    Linux中19个MySQL数据库管理命令
    扫描器（xray和bp联动）
    1532_AURIX_TriCore内核架构_中断
    Redis入门，Idea操作Redis
    学习java第五十一天
    【C++】十大排序算法之 插入排序 & 希尔排序
    网络安全—黑客技术—自学笔记
  • 原文地址：https://blog.csdn.net/weixin_45650003/article/details/125978437