Java-master（github）教材整理

helloworld

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

注释

//注释：用于解释说明程序的文字
/*
    注释的分类：
        单行注释 一般用于解释说明单行程序
            格式是：//注释文字
        多行注释 一般用于解释说明多行程序
            格式是：
        文档注释 一般是对类或者方法进行说明，被javadoc工具解析生产一个文档说明书。
            格式是：
*/

//注意：多行注释不能嵌套写，而单行注释可以。

//这是我的学生案例
//class是java中用来定义类的
//定义类的格式是：class 类名

/*
    这是我的学生案例
    class是java中用来定义类的
    定义类的格式是：class 类名
*/

/**  */
class Student {
    public static void main(String[] args) {
        System.out.println("我是学生");
    }
}

带注释的helloworld

/*
    需求：我要完成HelloWorld案例

    分析：
        A:java语言最基本的单位是类，所以我们首先要定义一个类
        B:java程序要想能够独立运行，必须有主方法
        C:如果想要程序有输出，必须有输出语句

    步骤：
        A:定义类的格式
            class 类名 {
                //类体
            }
        B:主方法的格式
            public static void main(String[] args) {
                //方法体
            }
        C:输出语句的格式
            System.out.println("这里的内容是可以改");

    最后把我们的思想用代码给体现出来
*/
//这是我的带注释的HelloWorld案例
//class用来定义类
class HelloWorld {
    /*
        这是main方法
        main方法是程序的入口
        jvm会自动调用main方法
    */
    public static void main(String[] args) {
        //这是输出语句
        System.out.println("HelloWorld");
    }
}

/*
    注释的作用：
        A:解释说明程序，提高程序的阅读性
        B:可以帮助我们调试程序
*/
class Demo {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        System.out.print("我爱林青霞");   //println与print区别在于换行与非换行
        System.out.print("我爱Java");
        System.out.print("我爱张瑜");
    }
}

关键字

/*
    关键字：被Java语言赋予特定含义的单词

    关键字的特点：关键字都是小写的

    关键字注意事项
        A:goto和const作为保留字存在,目前并不使用
        B:类似Editplus这样的高级记事本,针对关键字有特殊的颜色标记，非常直观
*/
class KeyWord {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

标识符

/*
    标识符：就是给类,接口,方法,变量等起名字时使用的字符序列(字符串)

    组成规则：
        A:英文字母大小写
        B:数字
        C:_和$

    注意事项：
        A:不能以数字开头
        B:不能是Java中的关键字
        C:区分大小写
            Student,student 这是两个名称

    常见的命名规则：见名知意
        A:包 其实就是文件夹,用于解决相同类名问题
            全部小写
            单级：com
            多级：cn.itcast

        B:类或者接口
            一个单词：首字母大写
                Student,Person,Teacher
            多个单词：每个单词的首字母大写
                HelloWorld,MyName,NameDemo

        C:方法或者变量
            一个单词：全部小写
                name,age,show()
            多个单词：从第二个单词开始，每个单词首字母大写
                myName,showAllStudentNames()

        D:常量
            一个单词：全部大写
                AGE
            多个单词：每个单词都大写，用_连接
                STUDENT_MAX_AGE
*/

class NameDemo {
    public static void main(String[] args) {

        System.out.println("Hello World!");
    }
}

常量

/*
    常量：在程序执行的过程中其值不可以发生改变
            举例：π

    分类：
        A:字面值常量
            1，12.5
        B:自定义常量(面向对象部分讲解)

    字面值常量分类：
        A:字符串常量 用""括起来的内容        String
        B:整数常量 所有的整数数据           int
        C:小数常量 所有的带小数的数据        float/double
        D:字符常量 用单引号括起来的内容      char
        E:布尔常量 只有两个值：true和false  blolean
        F:空常量 null(数组部分去讲解)       null
*/
class ConstantDemo {
    public static void main(String[] args) {
        //字符串常量
        System.out.println("HelloWorld");

        //整数常量
        System.out.println(100);

        //小数常量
        System.out.println(12.345);

        //字符常量
        System.out.println('A');
        //下面的是错误的
        //System.out.println('BC');//此条错误
        System.out.println('1');

        //布尔常量
        System.out.println(true);
        System.out.println(false);
    }
}

进制转换

/*
    二进制
        由0,1组成。以0b开头
    八进制
        由0,1,…7组成。以0开头
    十进制
        由0,1,…9组成。整数默认是十进制的
    十六进制
        由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头

*/
class JinZhiDemo {
    public static void main(String[] args) {
        System.out.println(0b100);//
        System.out.println(0100);//
        System.out.println(100);//
        System.out.println(0x100);//
    }
}

变量

/*
    成员变量和局部变量的区别：
        A:在类中的位置不同
            成员变量 类中方法外
            局部变量 方法内或者方法声明上
        B:在内存中的位置不同
            成员变量 堆内存
            局部变量 栈内存
        C:生命周期不同
            成员变量 随着对象的存在而存在，随着对象的消失而消失
            局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
        D:初始化值不同
            成员变量 有默认的初始化值
            局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

        注意：
            如果有同名的变量，一般会采用就近原则。
*/
class VariableDemo {
    //成员变量 堆内存
    int x;

    public static void main(String[] args) {
        //局部变量 栈内存
        int y;
        y = 0;  //如果不赋值,将报错,成员变量有默认初始值.
        System.out.println(y);

        VariableDemo vd = new VariableDemo();
        System.out.println(vd.x);
    }
}

数据类型

/*
    为了更好的表达现实世界的事物，Java针对不同的事物提供了不同的数据类型。

    数据类型：
        基本类型：4类8种
        引用类型：类，接口，数组。(后面讲)

    基本类型:
        整数：                占用的内存空间
            byte            1字节
                                01111111
                                10000000(1既表示符号位，又表示数值 -128)
            short            2字节
            int                4字节
            long            8字节
        浮点数：
            float            4字节
            double            8字节
        字符：
            char            2字节
        布尔：
            boolean            未知。1字节

    面试题：
        Java中字符可以存储一个汉字吗?
        可以。因为Java语言采用的是unicode编码，
        而unicode编码的每个字符是两个字节，
        所以，java中的字符可以存储一个汉字。

    注意：
        整数默认是int类型
        浮点数默认是double类型

        long类型的变量，要加l或者L。
        float类型的变量，要加f或者F。

        在同一对{}里面，是不能有同名的变量。
*/
class DataType {
    public static void main(String[] args) {
        //定义变量的格式：
        //数据类型 变量名 = 初始化值;

        //定义byte类型的变量
        byte b = 1;
        System.out.println(1);
        System.out.println(b);

        //定义short类型的变量
        short s = 100;
        System.out.println(s);

        //定义int类型的变量
        int i = 100000;
        System.out.println(i);

        //报错
        //int j = 2147483648;
        //System.out.println(j);

        //定义long类型的变量
        long l = 2147483648L;
        System.out.println(l);

        //定义float类型的变量
        float f = 12.34F;
        System.out.println(f);

        //定义double类型的变量
        double d = 23.56;
        System.out.println(d);

        //定义char类型的变量
        char ch = 'a';
        System.out.println(ch);

        //定义boolean类型的变量
        boolean flag = true;
        System.out.println(flag);
    }
}

类型转换

/*
    +是一个运算符, 我们应该能够看懂，做数据的加法。

    参与运算的数据，要求类型一致。

    boolean类型不能转换为其他的数据类型。

    隐式转换：
        A:byte,short,char-->int-->long-->float-->double
        B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
*/
class DataTypeDemo {
    public static void main(String[] args) {
        //类型一样的数据
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        int c = a + b;
        System.out.println(c);
        System.out.println("--------------");

        //定义变量
        byte by = 3;
        int i = 4;
        System.out.println(by + i);
        int j =    by + i;
        System.out.println(j);
    }
}

/*
    强制转换:从大到小，不建议使用，因为可能有精度的丢失。
        目标类型 变量名=(目标类型)(被转换的数据);
*/
class DataTypeDemo2 {
    public static void main(String[] args) {
        //定义变量
        byte by = 3;
        int i = 4;
        byte bb = (byte)(by + i);
        System.out.println(bb);
    }
}

/*
    +:做加法操作
        A:针对数据操作
        B:针对字符进行做+
            ASCII码表
                '0'    48
                'A'    65
                'a'    97
        C:针对字符串进行做+
            在字符串的操作中，叫字符串连接符
*/
class DataTypeDemo3 {
    public static void main(String[] args) {
        System.out.println('a');
        System.out.println('a'+1);
        System.out.println('A'+0);
        System.out.println('0'+0);
        System.out.println("-----------");

        System.out.println('a'+'b');
        System.out.println("a"+"b");

        System.out.println("hello"+'a'+1); //左边字符串，往后拼的都是字符串
        System.out.println('a'+1+"hello");
        System.out.println("5+5="+5+5);
        System.out.println(5+5+"=5+5");
    }
}

/*
    byte b1=3,b2=4,b;
    b=b1+b2;
    b=3+4;
    哪句是编译失败的呢？为什么呢？
        b=b1+b2;

    原因：
        变量相加，它首先提示类型，再做操作。
        常量相加，它先做操作，然后判断结果是否在左边的范围内容，如果在就不报错。如果不在，报错。
*/
class DataTypeTest {
    public static void main(String[] args) {
        byte b1=3,b2=4,b;
        //b = b1+b2; //右边类型自动提升
        b = 3+4;
    }
}

/*
    byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
*/
class DataTypeTest2 {
    public static void main(String[] args) {
        //byte b = 130;

        //解决方案
        //方案1
        //int a  = 130;

        //方案2
        byte b = (byte) 130;
        System.out.println(b);
    }
}

/*
    十进制：130

    A:第一步，先把十进制转换为二进制
        二进制：000000000 000000000 000000000 100000010
        由于此二进制是一个正数，所以，补码也是000000000 000000000 000000000 100000010。

    B:做强制类型转换
        二进制：000000000 000000000 000000000 100000010
        截取后就变成了：100000010

    C:操作后的数据是补码，你看到的是原码
                符号位        数值位
        补码：    1            00000010
        反码：    1            00000001
        原码：    1            11111110
*/

class DataTypeTest3 {
    public static void main(String[] args) {
        byte b = (byte)300;
        System.out.println(b);

        System.out.println((byte)127);
        System.out.println((byte)128);
        System.out.println((byte)129);
        System.out.println((byte)130);
        System.out.println((byte)131);
    }
}

/*
    十进制：300

    A:把十进制转换为二进制
        00000000 00000000 00000001 00101100

    B:截取
        0 0101100
*/

算数运算符

/*
    运算：对常量和变量进行操作的过程称为运算。
    运算符：对常量和变量进行操作的符号称为运算符
    表达式：由运算符把常量和变量连接起来的式子
            a + b
            注意：表达式必须有结果

    常见的运算符：
        算术运算符
        赋值运算符
        比较运算符
        逻辑运算符
        位运算符
        三目运算符

    算术运算符：
        +，-，*，/，%，++，--
*/
class OperatorDemo {
    public static void main(String[] args) {
        System.out.println(10+20);
        System.out.println(10-20);
        System.out.println(10*20);
        //整数相除，只能得到整数
        System.out.println(10/20);
        //要想得到小数，可以乘以或者除以1.0
        System.out.println(10/1.0/20);

        //加法的用法:正号,加法,字符串连接符
        System.out.println(+5);
        System.out.println(1+2);
        System.out.println("1"+"2");
    }
}

赋值运算符

/*
    赋值运算符：
        基本：=
        复合：+=,-=,*=,/=,%=,...
*/
class OperatorDemo {
    public static void main(String[] args) {
        //把10赋值给int类型的变量a
        int a = 10;

        //复合的用法
        int b = 10;
        b += 20; //结果等价于：b = b + 20;
        System.out.println(b);
    }
}

关系运算符

/*
    关系运算符：
        ==,!=,>,>=,<,<=

    特点：
        无论表达式是简单还是复杂，结果肯定是boolean类型。

    注意事项：
        关系运算符“==”不能误写成“=” 。
*/
class OperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 20;
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println((a + b*c) == (a*b + c));
        System.out.println("----------------");

        System.out.println(a = b); //把b的值赋值给a，把a的值作为结果留下来
        System.out.println(a = c);
    }
}

逻辑运算符

/*
    逻辑运算符：
        &,|,!,^
        &&,||

    注意：
        逻辑运算符连接的应该是一个布尔表达式。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //&,|,!,^
        int a = 10;
        int b = 20;
        int c = 30;

        //&:逻辑与    有false则false
        System.out.println(a>b & a>c); //false & false = false
        System.out.println(a>b & a<c); //false & true = false
        System.out.println(a<b & a>c); //true & false = false
        System.out.println(a<b & a<c); //true & true = true
        System.out.println("--------");

        //|:逻辑或    有true则true
        System.out.println(a>b | a>c); //false | false = false
        System.out.println(a>b | a<c); //false | true = true
        System.out.println(a<b | a>c); //true | false = true
        System.out.println(a<b | a<c); //true | true = true
        System.out.println("--------");

        //^:逻辑异或 相同false，不同true。
        //情侣：男男，男女，女男，女女
        System.out.println(a>b ^ a>c); //false ^ false = false
        System.out.println(a>b ^ a<c); //false ^ true = true
        System.out.println(a<b ^ a>c); //true ^ false = true
        System.out.println(a<b ^ a<c); //true ^ true = false
        System.out.println("--------");

        //!:逻辑非
        System.out.println((a>b));//false
        System.out.println(!(a>b));//true
        System.out.println(!!(a>b));//false
        System.out.println(!!!(a>b));//true
        System.out.println(!!!!(a>b));//false
    }
}

位运算符

/*
    位运算符：位运算符一定是先把数据转成二进制，然后再运算。

    面试题：&和&&的区别?
            A:&和&&都可以作为逻辑运算，&&具有短路效果。
            B:&还可以作为位运算。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //&,|,^,~
        System.out.println(3 & 4); //
        System.out.println(3 | 4); //
        System.out.println(3 ^ 4); //
        System.out.println(~3); //
    }
}

/*
    A:计算出3，4的二进制
        3的二进制：00000000 00000000 00000000 00000011
        4的二进制：00000000 00000000 00000000 00000100
    B:位&运算    有0则0
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
       ------------------------------------
        00000000 00000000 00000000 00000000
    C:位|运算    有1则1
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
       ------------------------------------
        00000000 00000000 00000000 00000111
    D:位^运算    相同则0，不同则1
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
       ------------------------------------
        00000000 00000000 00000000 00000111
    E:位~运算 把数据每个位都按位取反
        00000000 00000000 00000000 00000011
       ~11111111 11111111 11111111 11111100
     反:11111111 11111111 11111111 11111011
     原:10000000 00000000 00000000 00000100
*/

三元运算符

/*
    三元运算符：
    格式
        (关系表达式)?表达式1：表达式2；

    执行流程：
        计算关系表达式，看其返回值
            true:表达式1就是整个表达式的值
            false:表达式2就是整个表达式的值

*/
class OperatorDemo {
    public static void main(String[] args) {
        //获取两个数据中的较大值
        int x = 3;
        int y = 4;
        int z = (x > y)? x : y;
        System.out.println(z);

        //比较两个数是否相等
        int a = 4;
        int b = 4;
        //boolean flag = (a==b)?true:false;
        boolean flag = (a == b);
        System.out.println(flag);

        //获取三个数据中的较大值
        int c = 30;
        int d = 40;
        int e = 50;
        //int max = (c>d)?(c>e?c:e):(d>e?d:e);
        int temp = (c>d)?c:d;
        int max = (temp>e)?temp:e;
        System.out.println(max);
    }
}

键盘录入数据

/*
    为了程序的数据更加的灵活，我们决定加入键盘录入数据。

    如何使用键盘录入数据呢?目前你就给我记住了。
    A:导包
        import java.util.Scanner;

        在class的上面
    B:创建对象
        Scanner sc = new Scanner(System.in);
    C:获取数据
        int i = sc.nextInt();
*/
import java.util.Scanner;

class OperatorDemo {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个整数：");
        //获取数据
        int i = sc.nextInt();

        System.out.println("i:"+i);
    }
}

顺序结构语句

/*
    是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，
    依次执行，程序中大多数的代码都是这样执行的。

    总的来说：写在前面的先执行，写在后面的后执行
*/
class OrderDemo {
    public static void main(String[] args) {
        System.out.println("我爱林青霞");
        System.out.println("我爱Java");
        System.out.println("我爱张曼玉");
        System.out.println("林青霞爱张曼玉");
    }
}

选择结构（if语句）

/*
    选择结构：if语句，switch语句。

    if语句有三种格式。

    if语句格式1：
        if(关系表达式) {
             语句体;
        }

    执行流程：
        A:计算关系表达式，看其结果
        B:如果是true，就执行语句体
          如果是false，就不执行语句体
        C:继续向下执行
*/
class IfDemo {
    public static void main(String[] args) {
        int x = 3;

        if(x == 3) {
            System.out.println("x等于3");
            //x = 10;
        }

        if(x > 5) {
            System.out.println("x大于5");
        }

        System.out.println("over");
    }
}

选择结构（switch语句）

/*
    switch语句格式：
        switch(表达式) {
            case 值1：
                语句体1;
                break;
            case 值2：
                语句体2;
                break;
                …
            default：
                语句体n+1;
                break;
        }

        格式解释：
            A:switch表示这是switch语句
            B:表达式的取值
                byte,short,int,char
                JDK5以后可以是枚举类型。(enum)
                JDK7以后可以是字符串。(String)
            C:case后面跟的是要和表达式进行比较的值
            D:语句体可以是多条语句
            E:break表示中断，结束的意思，可以结束switch语句
            F:default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

        面试题：
            switch的表达式可以是byte类型吗?可以是long类型吗?可以是String类型吗?
                可以。
                不可以。
                JDK7以后可以。

        执行流程：
            A:首先计算出表达式的值
            B:其次，和case依次比较，一旦有对应的值，就会执行相应的语句，
              在执行的过程中，遇到break就会结束。
            C:最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

        需求：根据键盘录入的数值1，2，3，…7输出对应的星期一，星期二，星期三…星期日。

        分析：
            A:键盘录入数据，用Scanner实现
            B:对录入的数据进行判断，用switch实现
            C:输出对应的结果
*/
import java.util.Scanner;

class SwitchDemo {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //键盘录入数据
        System.out.println("请输入一个数据(1-7)：");
        int week = sc.nextInt();

        //用switch语句实现
        switch(week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("你输入的数据有误");
                break;
        }
    }
}

循环语句（for）

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

        执行流程：
        A:首先执行初始化语句
        B:其次执行判断条件语句，看其返回值
            如果是true，就继续
            如果是false，循环结束
        C:执行循环体语句
        D:执行控制条件语句
        E:回到B
*/
class ForDemo2 {
    public static void main(String[] args) {
        //在控制台输出10次HelloWorld
        for(int x=0; x<10; x++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------------");

        //初始化不从0开始
        for(int x=1; x<=10; x++) {
            System.out.println("HelloWorld");
        }    

        for(int x=1; x<11; x++) {
            System.out.println("HelloWorld");
        }

        for(int x=10; x>0; x--) {
            System.out.println("HelloWorld");
        }
    }
}

循环语句（while）

/*
    while循环的格式：
        while(条件表达式) {
            语句体;
        }

    变形格式：
        初始化语句;
        while(判断条件语句) {
            循环体语句;
            控制条件语句;
        }

        for(初始化语句;判断条件语句;控制条件语句) {
             循环体语句;
        }
    由此可见while循环和for循环是可以等价转换的。
*/
class WhileDemo {
    public static void main(String[] args) {
        //for
        /*
        for(int x=0; x<10; x++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------------");
        */

        //while
        /*
        int x=0;
        while(x<10) {
            System.out.println("HelloWorld");
            x++;
        }
        */

        //求和
        //for
        /*
        int sum = 0;
        for(int x=1; x<=100; x++) {
            sum+=x;
        }
        System.out.println("1-100之和是："+sum);
        */

        //while
        /*
        int sum = 0;
        int x = 1;
        while(x<=100) {
            sum += x;
            x++;
        }
        System.out.println("1-100之和是："+sum);
        */

        //水仙花
        //for
        /*
        for(int x=100; x<1000; x++) {
            int ge = x%10;
            int shi = x/10%10;
            int bai = x/10/10%10;

            if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)) {
                System.out.println(x);
            }
        }
        */

        //while
        int x = 100;
        while(x<1000) {
            int ge = x%10;
            int shi = x/10%10;
            int bai = x/10/10%10;

            if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)) {
                System.out.println(x);
            }

            x++;
        }
    }
}

循环语句（do…while）

/*
    do...while格式：
        do {
            语句体;
        }while(条件表达式);

    变形格式：
        初始化语句;
        do {
            循环体语句;
            控制条件语句;
        }while(判断条件语句);

        for(初始化语句;判断条件语句;控制条件语句) {
             循环体语句;
        }
*/
class DoWhileDemo {
    public static void main(String[] args) {
        /*
        int sum = 0;
        for(int x=1; x<=100; x++) {
            sum+=x;
        }
        System.out.println(sum);
        */

        //do...while
        int sum = 0;
        int x = 1;
        do{
            sum+=x;
            x++;
        }while (x<=100);
        System.out.println(sum);
    }
}

循环语句（嵌套使用）

/*
    需求：请输出如下图形
            *
            **
            ***
            ****
            *****
*/
class ForForDemo2 {
    public static void main(String[] args) {
        //我们先输出一个5行5列的星形
        /*
        for(int x=0; x<5; x++) {
            for(int y=0; y<5; y++) {
                System.out.print("*");
            }
            System.out.println();
        }
        */

        //而我们现在需要的是下半部分
        //通过观察图形：我们知道行没有变化，是列在变化
        //第一行：1列
        //第二行：2列
        //第三行：3列
        //第四行：4列
        //第五行：5列
        //既然是一个变化的数，那么我们就定义一个变量
        /*
        int z = 0;
        for(int x=0; x<5; x++) {
            for(int y=0; y<=z; y++) {
                System.out.print("*");
            }
            System.out.println();
            z++;
        }
        */

        //我们发现z的变化和x的变化其实是一致的
        //所以我们根本就没有必要定义z变量，直接把z用x替换
        for(int x=0; x<5; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("---------");

        for(int x=1; x<=5; x++) {
            for(int y=1; y<=x; y++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

控制跳转语句

/*
    根据要求填空
*/
class BreakAndContinue {
    public static void main(String[] args) {
        for(int x=1; x<=10; x++) {
            if(x%3==0) {
                //在此处填写代码
                break;
                //continue;
                //System.out.println("Java基础班");
            }
            System.out.println("Java基础班");
        }

        //我想在控制台输出2次:“Java基础班“
        //我想在控制台输出7次:“Java基础班“
        //我想在控制台输出13次:“Java基础班“
    }
}

/*
    break:中断

    break的使用场景：
        A:在选择结构switch语句中
        B:在循环语句中
        离开使用场景的存在是没有意义的

    break:
        A:跳出单层循环
        B:跳出多层循环(了解)
            带标签的用法
*/
class BreakDemo {
    public static void main(String[] args) {
        for(int x=0; x<10; x++) {
            //System.out.println(x);
            if(x%2==0) {
                break;
                //break后面是不能有东西的
                //System.out.println(x);
            }

            System.out.println(x);
        }
        System.out.println("-------------");

        wc:for(int x=0; x<3; x++) {
            nc:for(int y=0; y<4; y++) {
                System.out.print("*");
                break;
            }
            System.out.println();
        }
    }
}

/*
    continue的使用场景：
        在循环语句中
        离开使用场景的存在是没有意义的

    continue的作用：
        A:单层循环对比break，然后总结两个的区别
            break  退出当前循环
            continue  退出本次循环
        B:也可以带标签的使用

*/
class ContinueDemo {
    public static void main(String[] args) {
        //continue;

        for(int x=0; x<10; x++) {
            if(x%2==0) {
                //break;  //结束当前循环
                continue; //结束本次循环操作，进入下一次操作
            }
            System.out.println(x);
        }

        wc:for(int x=0; x<3; x++) {
            nc:for(int y=0; y<4; y++) {
                System.out.print("*");
                continue wc;
            }
            System.out.println();
        }
    }
}

/*
    return：结束方法的。
*/
class ReturnDemo {
    public static void main(String[] args) {
        for(int x=0; x<10; x++) {
            if(x%3==0) {
                //break;
                //continue;
                return;
            }
            System.out.println(x);
        }

        System.out.println("over");
    }
}

方法

/*
    方法：完成特定功能的代码块

    格式：
        修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
            方法体;
            return 返回值;
        }

    修饰符：public static
    返回值类型：功能最终的值的数据类型
    方法名：是为了方便调用而起的一个名字
    参数：
        形式参数：用于接受实际参数的变量
        实际参数：实际参与运算的数据
    方法体：完成特定功能的代码
    return 返回值：通过return把结果返回给调用者

    我们虽然知道了方法的格式，那么我们该如何写一个方法呢?
    两个明确：
        A:返回值类型
            结果的数据类型
        B:参数列表
            有几个参数参加，并且每个参数的数据类型是什么

    需求：求两个数据之和的案例
        A:我没有说数据的类型，默认int类型。
        B:求两个数据的和
            说明有两个参数参加，并且默认都是int类型
        C:两个int类型相加的结果是什么类型呢?
            是int类型，所以返回值类型这里是int类型

    方法的执行特点：
        不调用不执行。

    有明确返回值的方法的调用：
        A:单独调用，没有意义。
        B:输出调用，不是很好，因为我们可能需要针对结果还要进行其他的操作。
        C:赋值调用，推荐方式。
*/
class MethodDemo {
    public static void main(String[] args) {
        //定义两个变量
        int x = 10;
        int y = 20;

        //单独调用
        //sum(x,y);

        //输出调用
        System.out.println(sum(x,y));

        //赋值调用
        int result = sum(x,y);
        //result进行操作
        System.out.println(result);
    }

    //如果我自己要想写一个方法
    public static int sum(int a,int b) {
        int c = a + b;
        return c;
    }
}

方法重载

/*
    方法重载：
        在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
        和返回值类型无关。
*/
class MethodDemo {
    public static void main(String[] args) {
        //需求：请写一个功能，实现两个数据的求和
        System.out.println(sum(10,20));

        //需求：请写一个功能，实现三个数据的求和
        //System.out.println(sum2(10,20,30));
        System.out.println(sum(10,20,30));

        System.out.println(sum(1.5,2.5));
    }

    public static int sum(int a,int b) {
        return a + b;
    }

    /*
    public static int sum2(int a,int b,int c) {
        return a + b + c;

        //方法的嵌套调用
        //return sum(sum(a,b),c);
    }
    */

    //由于方法名要表达的其实是该方法的作用
    //所以，sum2这个名字不好，还是要用sum 比较好
    public static int sum(int a,int b,int c) {
        return a + b + c;
    }

    public static double sum(double a,double b) {
        return a + b;
    }
}

一维数组

/*
    数组：存储同一种数据类型的多个元素的集合。(也可以称为容器)

    数组的定义格式：
        格式1：数据类型[] 数组名;
            int[] arr;
        格式2：数据类型 数组名[];
            int arr[];

        推荐方式1。

    现在的数组没有元素，使用是没有意义的。
    接下来，我们要对数组进行初始化。
    那么，我们如何对数组进行初始化呢?
        动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
        静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

    动态初始化：
        数据类型[] 数组名 = new 数据类型[数组长度];

*/
class ArrayDemo {
    public static void main(String[] args) {
        //按照动态初始化数组的格式，我们来定义一个存储3个int类型元素的数组
        int[] arr = new int[3];

        /*
            左边：
                int:说明数组中的元素的数据类型。
                []:说明这是一个数组
                arr:数组的名称
            右边：
                new:为实体(对象)开辟内存空间
                    Scanner sc = new Scanner(System.in);
                int:说明数组中的元素的数据类型。
                []:说明这是一个数组
                3:说明的是数组中的元素个数
        */

        //我们如何获取里面的值呢?
        //数组名称
        System.out.println(arr); //[I@778b3fee 地址值
        //如何获取元素值呢?
        //数组为每个元素分配了一个编号，这个编号的专业叫法：索引。
        //而且是从0开始编号的。也就是说数组的最大编号是长度-1。
        //有了编号以后，我们就可以通过数组名和编号的配合取得数组元素
        //格式：数组名[编号];
        System.out.println(arr[0]); //
        System.out.println(arr[1]); //
        System.out.println(arr[2]); //
    }
}

二位数组

/*
    二维数组：元素为一维数组的数组。

    定义格式1：
        数据类型[][] 变量名 = new 数据类型[m][n];

        m:m表示这个二维数组有多少个一维数组
        n:n表示每一个一维数组的元素个数

        变形：
            数据类型 变量名[][] = new 数据类型[m][n];
            数据类型[] 变量名[] = new 数据类型[m][n];

            int[] x,y[];
*/
class Array2Demo {
    public static void main(String[] args) {
        //定义一个二维数组
        int[][] arr = new int[3][2];
        //表示arr这个二维数组有三个元素
        //每个元素是一个一维数组
        //每一个一维数组有2个元素

        System.out.println(arr); //[[I@778b3fee
        System.out.println(arr[0]); //[I@57125f92
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //如何输出元素呢?
        System.out.println(arr[0][1]);
        System.out.println(arr[2][2]);
    }
}

To be continued