Java学习笔记

Java学习

基本数据类型

基本数据类型 整数型 byte short int long 浮点型 float double 字符型 char 布尔型 boolean

注意事项：

字符串不是基本类型，而是引用类型；
浮点型可能只是近似值，不是精确值；
数据范围与字节数不一定相关，例如float数据范围比long更广，但是float是4字节，long是8字节；
浮点数当中默认类型是double，如果一定要使用float类型，需要加一个后缀F；如果是整数，默认为int类型，如果使用long类型，加一个后缀L；

变量赋值

在给变量进行赋值的时候，如果右侧的表达式中全都是变量，没有任何常量，那么编译器javac将会直接将若干个常量表达式计算得到结果。 short result = 5 + 8； //等号右边全都是常量，没有任何变量参与运算编译之后，得到的.class字节码文件当中相当于【直接就是】 short result = 13; 右侧的常量结果数值没有超过左侧范围，所以正确

这称为 "编译器的常量优化"

但是注意：一旦表达式中有变量参与，就不能进行这种优化

public static void main(String[] args) {
        short num1 = 10; //正确写法，右侧没有超过左侧的范围
        
        short a = 5;
        short b = 8;
        // short + short --> int + int --> int
        // short result = a + b; //错误写法，左侧需要时int类型
        
        //右侧不用变量，二十采用常量，而且只有两个常量，没有其他
        short result = 5 + 8;
        System.out.println(result);
    }

运算符

自增运算符：++ 自减运算符：--

使用方法: 1.单独使用： 2.混合使用：和其他操作一起使用使用区别： 1.在单独使用的时候，前++和后++没有任何区别 2.在混合使用的时候，有【重大区别】。 A：如果是前++，那么变量马上+1，然后拿着结果进行使用。 B：如果是后++，那么首先使用本来的数值，然后再让变量+1。

注意事项: 只有变量才能使用自增自减运算符，常量不可以使用。

public static void main(String[] args) {
        int num1 = 10;
        //单独使用，后++
        num1++;
        System.out.println(num1); //11
        //单独使用，前++
        ++num1;
        System.out.println(num1); //12
        
        System.out.println("===================");
        
        int num2 = 20; 
        
        //混合使用，前++
        System.out.println(++num2); //21
        
        int num3 = 20;
        //混合使用，后++
        System.out.println(num3++); //20
    }

赋值运算符分为：

基本赋值运算符：就是一个等号“=”，代表将右侧得数据交给左侧的变量； int a = 30;

符合赋值运算符： += a += 1 相当于 a = a + 1 -= b -= 4 相当于 b = b - 4 *= c *= 5 相当于 c = c * 5 /= d /= 6 相当于 d = d / 6 %= e %= 7 相当于 e = e % 7 注意事项： 1.只有变量才能使用赋值运算符，常量不能进行赋值； 2.复合赋值运算符其中隐含了一个强制类型转换；

public static void main(String[] args) {
        int a = 10;
        // 按照公式翻译 a = a + 5；
        // a = 10 + 5;
        // a = 15;
        // a本来是10，现在重新赋值得到15；
        a += 5;
        System.out.println(a); // 15
        
        int x = 10;
        x %= 3;
        System.out.println(x); // 1
        
        byte num = 30;
        // num = num + 5;
        // num = byte + int;
        // num = int + int;
        // num = int;
        // num = (byte) int;
        num += 5;
        System.out.println(num); //35
    }

比较运算符：

'>' 大于

< 小于 = 大于等于 <= 小于等于 == 相等，【两个等号才是相等，一个等号是赋值】 != 不等

注意事项： 1.比较运算符的结果一定是一个Boolean值，成立就是ture值，不成立就是false值。 2.如果进行多次判断，不能连着写，数学中的写法：1 < x < 3 程序当中【不允许】这种写法。

public static void main(String[] args) {
        System.out.println(10 > 5); //ture
        int a = 10;
        int b = 12;
        System.out.println(a < b); //ture
        System.out.println(a >= b); //false
        System.out.println(a >= 10); //ture
        
        int x = 2;
        // System.out.println(1< x <3); // 写法错误，编译报错，不能连着写！ 
    }

逻辑运算符

与（并且） && 全都是true，才是true；否则就是false 或（或者） || 至少一个是true，就是true；全都是false，才是false 非（取反）！本来是true，变成false；本来是false，变成true

与“&&”，或“||”，具有短路效果:如果左边已经可以判断的到最后结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项: 1.逻辑运算只能用于boolean值。 2.与、或需要左右各自一个boolean值；但是去翻只要有唯一的一个boolean值即可。 3.与、或两种运算符，如果有多个条件，可以连续写两个条件：条件A && 条件B 多个条件：条件A && 条件B && 条件C TIPS: 对于1 < x < 3的情况，应该拆分成两个部分，然后使用与运算符连接起来 int x = 2; 1 < x && x < 3;

public static void main(String[] args) {
        System.out.println(true && false); //false
        
        System.out.println(true && true); //true
        System.out.println(true && 10>5); //true
        System.out.println("==========");

        System.out.println(true || false); //true
        System.out.println(false || false); //false
        
        System.out.println("===============");

        System.out.println(true); //true 
        System.out.println(!true); //false 
        
        int a = 10;
        // false && ... ----> false
        System.out.println(false && ++a < 100);  //false
        // 短路 
        System.out.println(a); //10 
}

三元运算符

一元运算符:只需要一个数据就可以进行操作的运算符；例如：（取反）！；自增++；自减-- 二元运算符：需要两个数据才能进行的运算符：例如：加法+，减法-，赋值= 三元运算符：需要三个数据才能进行操作的运算符。格式：数据类型变量名称 = 条件判断？表达式A ：表达式B；

流程: 首先判断条件是否成立：如果成立为true，那么将表达式A的值赋值给左侧的变量；如果不成立魏false，那么将表达式B的值赋值给左侧的变量二者选其一

【注意事项】 1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求 2.三元运算符的结果必须被使用

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        // 数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B；
        // 判断a > b是否成立，如果成立将a的值赋给max；否则b；
        int max = a > b ? a : b; //最大值的变量
        System.out.println("最大值：" + max); // 20
        
        // int result = 3 > 4 ? 2.5 : 10; //错误: 不兼容的类型: 从double转换到int可能会有损失
        
        System.out.println(a > b ? a : b); //正确写法   
    }

流程控制

顺序语句

判断语句

if语句

格式：

if(判断条件) {

执行 // 满足判断条件时，不满足直接跳出

}

public static void main(String[] args) {
        System.out.println("今天发现一个网吧");
        int age = 16;
        if (age >= 18) {
            System.out.println("进入网吧");
            System.out.println("结账");
        }
        System.out.println("回家吃饭");
    }

if-else语句

格式：

if(判断条件) {

执行语句1 //满足条件时执行语句1

} else {

执行语句2 //不满足条件时执行语句2

}

if-elseExt语句

格式：

if(判断语句1) {

执行语句1 //满足条件1时执行语句1

} else if (判断语句2) {

执行语句2 //满足条件2时执行语句2

} else {

执行语句3 //都不满足条件时执行语句3

}

// x和y的关系满足如下：
// 如果 x >= 3,那么 y = 2x + 1;
// 如果 -1 < x <3 ,那么 y = 2x;
// 如果 x <= -1,那么 y = 2x - 1
public class Demo04IfElseExt {
    public static void main(String[] args) {
        int x =10;
        int y;
        if (x >= 3) {
            y = 2*x + 1;
        }
        else if (-1 < x && x < 3) {
            y = 2*x;
        }
        else {
            y = 2*x - 1;
        }
        System.out.println("结果是"+y);
    }

Exercise

public static void main(String[] args) {
        int score = 15;
        if (score >= 90 && score <= 100) {
            System.out.println("你的成绩是优秀");
        }
        else if (score >= 80 && score < 90) {
            System.out.println("你的成绩是好");
        }
        else if (score >= 70 && score < 80) {
            System.out.println("你的成绩是良");
        }
        else if (score >= 60 && score < 70) {
            System.out.println("你的成绩是及格");
        }
        else if (score <= 0 || score > 100) {
            System.out.println("错误");
        }
        else {
            System.out.println("你的成绩是不及格");
        }
    }

循环语句

循环结构的基本组成部分，一般可以分为四部分:

1.初始化语句：在循环开始最初执行，而且只做唯一一次。 2.条件判断：如果成立，则循环继续；如果不成立，则循环退出。 3.循环体：重复要做的事情内容，若干行语句。 4.步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要进行一次

switch语句

格式
switch(表达式) {
    case 常量1 :
        语句体1;
        break;
    case 常量2 :
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;

public static void main(String[] args) {
        int num = 10;
    switch (num) {
        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; //最后一个break语句可以省略，但建议不要省略
    }
}

Switch语句注意事项:

1.多个case后边的数值不可以重复

2.switch后边小括号当中只能是以下数据类型： 基本数据类型：byte/short/char/int 引用数据类型：String字符串、enum枚举

3.switch语句格式可以很灵活：前后顺寻可以颠倒，而且break语句还可以省略。 “匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。”

for循环

格式：

for (初始化表达式①；布尔表达式②；步进表达式④) { 循环体③ }

public static void main(String[] args) {
        /*for(初始化表达式；条件判断；步进语句) {
            循环体；
        }*/
        for (int i = 1;i <= 100;i++) {
            System.out.println("我错了" +i);
        }
        System.out.println("程序停止");
    }

while循环

while循环有一个标准格式，还有一个扩展格式

标准格式：
while（条件判断） {
    循环体
}

扩展格式：
初始化语句;
while(条件判断) {
    循环体
    步进语句
}

public static void main(String[] args) {
        int i = 1; //1.初始化语句
        while(i <= 10) { //2.条件判断
            System.out.println("我错了" + i); //3.循环体
            i++; //4.步进语句
        }
    }

do-while循环

do-while循环标准格式:

do {
    循环体
}   
    while(条件判断);

do-while循环扩展格式

1.初始化语句
do {
    循环体
    步进语句
}   
    while(判断条件);

public static void main(String[] args) {
        for(int i = 1; i <= 10; i++) {
            System.out.println("原谅" + i);
        }
        System.out.println("==============");
        
        int i = 1; //初始化语句
        do {
            System.out.println("原谅" + i); //循环体
            i++; //步进语句
        } while(i <= 10); //条件判断
    }

三种循环语句的区别

如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会至少执行一次
for循环的变量在小括号当中定义，只有循环内部才可以使用。while和do-while循环初始化语句本来就在外边，所以出来循环之后还可以继续使用

循环控制语句

break语句

break关键字的用法有常见的两种：

1.可以用在switch语句当中，一旦执行，整个switch语句立刻结束。 2.还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。

关于循环的选择：凡是次数确定的场景多用for循环，否则多用while循环。

public static void main(String[] args) {
        for (int i = 1; i <= 10;i++) {
            // 如果希望从第4次开始，后续全都不要了，就要打断语句。
            if (i == 4) { //如果当前是第四次循环
                break; // 那就打断循环
            }
            System.out.println("Hello " +i);
        }
    }

continue语句

另一种循环控制语句是continue关键字。一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。

public static void main(String[] args) {
        for (int i = 1; i<=10; i++) {
            if (i == 4) { //如果当前是第4层
                continue; //那么跳过当前次循环，马上开始下一次循环（第5层）
            }
            System.out.println(i+ "层到了。");
        }
    }

死循环

永远停不下来的循环，叫做死循环。

死循环的标准格式： while (true) { 循环体 }

public static void main(String[] args) {
        while(true) {
            System.out.println("I Love Java!");
        }
    }

方法

方法定义

定义一个方法的格式

public static void 方法名称() {
    方法体;
}

方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。

【注意事项】：
1.方法定义的先后顺序无所谓。
2.方法的定义不能产生嵌套包含关系。
3.方法定义好了以后，不会执行。如果想执行，一定要进行方法的【调用】。

如何调用方法，格式：
方法名称();

public static void main(String[] args) {
        farmer(); // 调用农民的方法
        seller(); // 调用商贩的方法
        cook(); // 调用厨子的方法
        me(); //调用自己的方法
    }
    
    // 我
    public static void me() {
        System.out.println("吃");
    }
    
    // 厨子
    public static void cook() {
        System.out.println("洗菜");
        System.out.println("切菜");
        System.out.println("炒菜");
        System.out.println("装盘");
    }
    
    //商贩
    public static void seller() {
        
        System.out.println("运输到市场");
        System.out.println("卖给厨子");
    }
    // 农民
    public static void farmer() {
        System.out.println("播种");
        System.out.println("浇水");
        System.out.println("施肥");
        System.out.println("收割");
        System.out.println("卖给小商贩");
    }

方法的调用

方法其实就是若干语句的功能集合

方法好比是一个工厂
蒙牛工厂    原料:奶牛、饲料、水
           产出物:奶制品
钢铁工厂    原料：铁矿石、煤炭
           产出物：钢铁建材

参数（原料）：就是进入方法的数据
返回值（产出物）：就是从方法中出来的数据

定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，...） {
    方法体
    return 返回值;
}

修饰符：现阶段的固定写法：public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型: 进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
PS:参数如果有多个，使用逗号分隔
方法体：方法需要做的事情，若干行代码
return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果

【注意事项】
return后面的“返回值”，必须与方法名称前面的“返回值类型”，保持对应。

定义一个两个int数字相加的方法，三要素:
返回值类型：int
方法名称：sum
参数列表： int a， int b

方法的三种调用格式
1.单独调用：方法名称（参数）；
2.打印调用：System.out.println(方法名称(参数))；
3.赋值调用：数据类型 变量名称 = 方法名称（参数）；

【注意】 此前学习的方法，返回值类型默认写成void，这种方法只能单独调用，不能进行打印调用或者赋值调用。

public static void main(String[] args) {
    // 单独调用
    sum(10,20);
    System.out.println("==========");

    // 打印调用
    System.out.println(sum(10,20)); //30
    System.out.println("============");

    //赋值调用
    int number = sum(15,25);
    System.out.println(""+number);
}

public static int sum(int a,int b) {
    System.out.println("方法执行了");
    int result = a + b;
    return result;
}

有参数：小括号当中有内容，当一个方法需要一些数据的条件，才能完成任务的时候，就是有参数。
例如两个数字的相加，必须知道两个数字是各自多少，才能相加。
无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
例如定义一个方法，打印固定10次HelloWorld。

public static void main(String[] args) {
    method1(10,20);
    System.out.println("============");
    method2();
}

// 两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算。
// 有参数

public static void method1(int a,int b) {
    int result = a * b;
    System.out.println("结果是：" + result);
}

// 例如打印输出固定10次的文本输出
public static void method2() {
    for (int i = 0; i < 10; i++) {
        System.out.println("HelloWorld" + i);
    }
}

练习

练习1

题目要求:定义一个方法，用来求出两个数字之和。（你帮我算，算完之后把结果告诉我。）
题目变形：定义一个方法，用来打印两个数字之和。（你来计算，算完之后你自己负责显示结果，不用告诉我。）

【注意事项】：
对于有返回值的方法，可以使用单独调用、打印调用或赋值调用。
但对于无返回值的方法，只能进行单独调用。

public static void main(String[] args) {
        // 我是main方法，我来调用你
        // 我调用你，你来帮我计算一下，算完之后，把结果告诉我的number变量。
        int number = getsum(10,20);             // 赋值调用
        System.out.println("返回值是：" + number);
        System.out.println("==============");

        printSum(100,200);
        System.out.println("==============");

        System.out.println(getsum(2,3));       // 打印调用
        getsum(2,3);                           // 正确写法，但是返回值没有用到

        System.out.println("=============");

        // 对于void没有返回值的方法，只能单独，不能打印或者赋值
//        System.out.println(printSum(2,3);       // 错误写法
//        System.out.println(void);

//        int number2= printSum(10,30); //错误写法
//        int number3 = void;
//        void number4 = void

    }


    // 我是一个方法，我负责两个数字相加。
    // 我有返回值int。谁调用我，我就把计算结果告诉谁。
    public static int getsum(int a,int b) {
        int result = a + b;
        return result;
    }
    // 我是一个方法，我负责两个数字相加。
    // 我没有返回值，我不会把结果告诉任何一个人，而是我自己打印输出
    public static void printSum(int a,int b) {
        int result = a + b;
        System.out.println("结果是：" + result);
    }

练习2

题目要求：定义一个方法：用来判断两个数字是否相同。

public static void main(String[] args) {

        System.out.println(isSame(10,20)); //false
        System.out.println(isSame(20,20)); //true

    }

    /*
    三要素：
    1.返回值类型：boolean
    2.方法名称：isSame
    3.参数列表：int a, int b
     */
    public static boolean isSame(int a, int b) {

//        boolean same;
        /*if (a == b) {
            same = true;
        } else {
            same = false;
        }*/

//        same = a == b ? true : false;

//        boolean same = a == b;

        return a == b;
    }

练习3

题目要求:
定义一个方法，用来求出1-100之间所有数字的和值结果。

public static void main(String[] args) {
    System.out.println("结果是：" + getSum());

}
/*
三要素:
返回值：有返回值，计算结果是一个int数字。
方法名称：getSum
参数列表：1-100数据范围已经确定，是固定的，所以不需要告诉我任何条件，不需要参数。
 */
public static int getSum() {
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    return sum;
}

使用方法的时候，注意事项:

1.方法应该定义在类当中，但是不能在方法当中再定义方法，不能嵌套 2.方法定义的前后顺序无所谓 3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用，打印调用，赋值调用 4.如果方法有返回值，那么必须写上[return 返回值;]不能没有 5.return后面的返回值数据，必须和方法的返回值类型，对应起来 6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。 7.对于方法当中最后一行的return可以省略不写。 8.一个方法当中可以有多个return语句，但是必须办证同时只有一个会被执行到。

public static int method1() {
        return 10;
    }

    public static void method2() {
//        return 10;  //错误写法！ 方法没有返回值，return后面就不能写返回值。
    return ; //没有返回值，只是结束方法的执行而已。               对应注意事项6
    }

    public static void method3() {
        System.out.println("AAA");
        System.out.println("BBB");
//        return; //最后一行的return可以不写
    }

    public static int getMax(int a, int b) {
        /*int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;*/

        if (a > b) {
            return a;
        } else {
            return b;
        }
    }

方法重载

对于功能类似的方法来说，因为参数列表不一样，需要记住很多不同的方法名称，太麻烦。

方法的重载（Overload）：多个方法的名称一样，但是参数列表不同好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能

方法重载与下列因素相关： 1.参数个数不同。 2.参数类型不同 3.参数的多类型顺序不同

方法的重载与下列因素无关： 1.与参数的名称无关 2.与方法的返回值类型无关

public static void main(String[] args) {
//        System.out.println(sumTwo(10,20)); //30
//        System.out.println(sumThree(10,20,30)); //60
//        System.out.println(sumFour(10,20,30,40)); //100
        System.out.println(sum(10,20));
    }

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

//    // 错误写法！与方法的返回值类型无关
//    public static double sum(int a, int b) {
//        return a + b + 0.0;
//    }

//    // 错误写法！与参数的名称无关
//    public static int sum(int x, int y) {
//        return x + y;
//    }
    
    // 重载的多种形式
    public static int sum(double a, int b) {
        return (int)(a + b);
    }

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

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

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

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

练习1

题目要求：
比较两个数据是否相等。
参数类型分别为两个byte类型，两个short类型，两个long类型，并在main方法中进行测试。

public static void main(String[] args) {
    byte a = 10;
    byte b = 20;
    System.out.println(isSame(a,b));

    System.out.println(isSame((short)20,(short)20));

    System.out.println(isSame(11,12));

    System.out.println(isSame(10L,20L));

}

public static boolean isSame(byte a, byte b) {
    System.out.println("两个byte参数方法的执行");
    return a == b;
}

public static boolean isSame(short a, short b) {
    System.out.println("两个short参数方法的执行");
    return a == b;
}

public static boolean isSame(long a, long b) {
    System.out.println("两个long参数方法的执行");
    return a == b;
}

public static boolean isSame(int a, int b) {
    System.out.println("两个int参数方法的执行");
    return a == b;
}

数组

数组：是一种容器，可以同时存放多个数据值。

数组的特点： 1.数组是一种引用数据类型 2.数组当中的多个数据，类型必须统一 3.数组的长度在程序运行期间不可改变

数组的初始化

数组的初始化（创建数组）：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式： 1.动态初始化（指定长度） 2.静态初始化（指定内容）

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

解析含义：左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型左侧的中括号：代表我是一个数组左侧的数组名称：给数组起一个名字右侧的new：代表创建数组的动作右侧的数据类型：必须和左侧的数据类型保持一致右侧中括号当中的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

动态初始化：在创建数组的时候，直接指定数组当中的元素个数。静态初始化：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

静态初始化基本格式： 数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，...}；

注意实项： 虽然静态初始化没有直接告诉长度，但是根据大括号里边的元素具体内容，也可以推算出长度。

动态初始化

public static void main(String[] args) {
    // 创建一个数组，里边可以存放300个int数据
    // 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
    int[] arrayA = new int[300];

    // 创建一个数组，存放10个double类型的数据
    double[] arrayB = new double[10];

    // 创建一个数组，存放5个字符串
    String[] arrayC = new String[5];
}

静态初始化

public static void main(String[] args) {
    // 直接创建一个数组，里边装的都是int数字，具体为：5、15、25
    int[] arrayA = new int[] {5,15,25};

    // 创建一个数组，用来装字符串，"Hello","World","Java"
    String[] arrayB = new String[] {"Hello","World","Java"};
}

使用静态初始化数组的时候，格式还可以省略一下。

标准格式： 数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，...}；

省略格式： 数据类型[] 数组名称 = {元素1，元素2，...}；

【注意事项】 1.静态初始化没有直接指定数组长度，但是仍然会自动推断得到长度 2.静态初始化标准格式可以拆分成为两个步骤。 3.动态初始化也可以拆分成为两个步骤 4.静态初始化一旦使用省略格式，就不能拆分成两个步骤

【使用建议】 如果不确定数组当中的具体内容，则用动态初始化，否则，已经确定了具体内容，用静态初始化。

public static void main(String[] args) {
        // 省略格式的静态初始化
        int[] arrayA = {10,20,30};

        // 静态初始化标准格式可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] {11,21,31};

        // 动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];

//        //静态初始化一旦使用省略格式，就不能拆分成两个步骤
//        int arrayD;
//        arrayD = {10,20,30};

数组的基本事项

*直接打印数组名称，得到的是数组对应的：内存地址哈希值。*

访问数组元素的格式：数组名称[索引值] 索引值：就是一个int数字，代表数组当中的元素编号。

【注意】 索引值从0开始，一直到“数组的长度-1”为止

public static void main(String[] args) {
    // 静态初始化的省略格式
    int[] array = {10,20,30};

    // 直接打印数组当中的元素
    System.out.println(array); // [I@50cbc42f [表示数组 I表示int型  @后边的数字50cbc42f是16进制数字
    System.out.println(array[0]); //10
    System.out.println(array[1]); //20
    System.out.println(array[2]); //30
    System.out.println("==================");

    // 也可以将数组当中的某一个元素赋值给变量
    int num = array[1];
    System.out.println(num);

使用动态初始化数组的时候，其中元素将会自动拥有一个默认值如果是整数类型：那么默认为0；如果是浮点类型，那么默认为0.0；如果是字符类型，那么默认为'\u0000'; 如果是boolean，那么默认为false值；如果是引用类型，那么默认为null。

注意事项： 静态初始化也有默认值的过程，只不过系统自动马上将默认值替换为了大括号当中的具体数值。

public static void main(String[] args) {
    // 动态初始化一个数组
    int [] array = new int[3];

    System.out.println(array); //内训地址值
    System.out.println(array[0]); //0
    System.out.println(array[1]); //0
    System.out.println(array[2]); //0
    System.out.println("===============");

    //将数值123赋值给array当中的1号元素
    array[1] = 123;
    System.out.println(array[0]); //0
    System.out.println(array[1]); //123
    System.out.println(array[2]); //0
}

arrayOne

public static void main(String[] args) {
    int[] array = new int[3]; //动态初始化
    System.out.println(array); //地址值
    System.out.println(array[0]); //0
    System.out.println(array[1]); //0
    System.out.println(array[2]); //0
    System.out.println("============");

    // 改变数组当中元素的内容
    array[1] = 10;
    array[2] = 20;
    System.out.println(array); //地址值
    System.out.println(array[0]); //0
    System.out.println(array[1]); //10
    System.out.println(array[2]); //20
}

arrayTwo

public static void main(String[] args) {
    int[] arrayA = new int[3]; //动态初始化
    System.out.println(arrayA); //地址值
    System.out.println(arrayA[0]); //0
    System.out.println(arrayA[1]); //0
    System.out.println(arrayA[2]); //0
    System.out.println("============");

    // 改变数组当中元素的内容
    arrayA[1] = 10;
    arrayA[2] = 20;
    System.out.println(arrayA); //地址值
    System.out.println(arrayA[0]); //0
    System.out.println(arrayA[1]); //10
    System.out.println(arrayA[2]); //20
    System.out.println("============");

    int[] arrayB = new int[3]; //动态初始化
    System.out.println(arrayB); //地址值
    System.out.println(arrayB[0]); //0
    System.out.println(arrayB[1]); //0
    System.out.println(arrayB[2]); //0
    System.out.println("============");

    // 改变数组当中元素的内容
    arrayB[1] = 100;
    arrayB[2] = 200;
    System.out.println(arrayB); //地址值
    System.out.println(arrayB[0]); //0
    System.out.println(arrayB[1]); //100
    System.out.println(arrayB[2]); //200
    System.out.println("============");
}

ArraySame

public static void main(String[] args) {
    int[] arrayA = new int[3]; //动态初始化
    System.out.println(arrayA); //地址值
    System.out.println(arrayA[0]); //0
    System.out.println(arrayA[1]); //0
    System.out.println(arrayA[2]); //0
    System.out.println("============");

    // 改变数组当中元素的内容
    arrayA[1] = 10;
    arrayA[2] = 20;
    System.out.println(arrayA); //地址值
    System.out.println(arrayA[0]); //0
    System.out.println(arrayA[1]); //10
    System.out.println(arrayA[2]); //20
    System.out.println("============");

    // 将arrayA的地址值赋值给arrayB。
    int[] arrayB = arrayA;
    System.out.println(arrayB); //地址值
    System.out.println(arrayB[0]); //0
    System.out.println(arrayB[1]); //10
    System.out.println(arrayB[2]); //20
    System.out.println("============");

    // 改变数组当中元素的内容
    arrayB[1] = 100;
    arrayB[2] = 200;
    System.out.println(arrayB); //地址值
    System.out.println(arrayB[0]); //0
    System.out.println(arrayB[1]); //100
    System.out.println(arrayB[2]); //200
    System.out.println("============");
}

数组的使用方法

数组的索引

ArrayIndex

数组的索引编号从0开始，一直到数组的长度-1.

如果访问数组元素的时候，索引编号不存在，那么将会数组索引越界异常 ArrayIndexOutOfBoundException

原因：索引编号写错了解决：修改成为存在的正确索引编号

public static void main(String[] args) {

    int[] array = {15, 25, 35};

    System.out.println(array[0]); //15
    System.out.println(array[1]); //25
    System.out.println(array[2]); //35

    //错误写法！并不存在3号元素，多以发生数组索引越界异常
    System.out.println(array[3]);
}

数组创建必须赋值

ArrayNull

所有的引用类型变量，都可以赋值为一个null值，代表其中什么都没有。

数组必须进行new初始化，才能使用其中的元素， 如果只是复制了一个null值，没有进行new创建 那么将会发生 空指针异常 NullPointerException

原因：忘了new 解决：补上new

public static void main(String[] args) {
    int[] array = null;
    array = new int[3];
    System.out.println(array[0]);
}

获取数组的长度

如何获取数组的长度，格式： 数组名称.length

这样将会得到一个int数字，代表数组的长度。

【】！！！！！ 数组一旦创建，程序运行期间，长度不可改变！！！！！！

public static void main(String[] args) {
    int[] arrayA = new int[3];

    int[] arrayB = {10, 20, 30, 8, 6, 2, 4, 56, 48, 10, 88, 69, 54};
    int len = arrayB.length;
    System.out.println("arrayB数组的长度是：" + len);
    System.out.println("==================");

    int[] arrayC = new int[3];
    System.out.println(arrayC.length); //3
    arrayC = new int[5];
    System.out.println(arrayC.length); //5

遍历数组

遍历数组：说的就是对数组当中的每一个元素进行逐一，挨个儿处理。默认处理方式就是打印输出

public static void main(String[] args) {
    int[] array = {15, 25, 35, 45, 50};

    // 首先使用原始方法
    System.out.println(array[0]); //15
    System.out.println(array[1]); //25
    System.out.println(array[2]); //35
    System.out.println(array[3]); //45
    System.out.println(array[4]); //50
    System.out.println("================");

    // 使用循环,次数其实就是数组的长度
    for (int i = 0; i < array.length; i++) {        // array.for.i
        System.out.println(array[i]);
    }
    System.out.println("================");

}

数组的反转

数组元素的反转：本来的样子：[1,2,3,4,5] 之后的样子：[5,4,3,2,1]

要求不能使用新数组，就用原来的唯一一个数组。

public static void main(String[] args) {

    int[] array = {10, 20, 30, 40, 50};
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
    System.out.println("=============");

    // 反转
    /*
    初始化语句：int min=0,max = array - 1;
    条件判断： min < max
    循环体：用第三个变量倒手
    步进表达式： min++,max--
     */
    for (int min=0,max = array.length - 1;min < max;min++,max--) {
        int temp = array[min];
        array[min] = array[max];
        array[max] = temp;
    }

    // 再次打印数组后来的样子
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}

获取数组最大值

public static void main(String[] args) {

    int[] array = {5, 15, 30, 20, 10000, 30};

    int max = array[0];
    for (int i = 1; i < array.length; i++) {
        // 如果当前元素比max更大，则换人
        if (array[i] > max) {
            max = array[i];
        }
    }
    // 谁最后最厉害，就能在max之中留下
    System.out.println("最大值：" +max);
}

获取数组最小值

public static void main(String[] args) {

    int[] array = {5, 15, 30, 20, 10000, -20, 30};

    int min = array[0];
    for (int i = 1; i < array.length; i++) {
        // 如果当前元素比max更大，则换人
        if (array[i] < min) {
            min = array[i];
        }
    }
    // 谁最后最厉害，就能在max之中留下
    System.out.println("最小值：" +min);
}

数组作为参数

数组可以作为方法的参数。！！！！！！！！！！！！！！！！！当调用方法的时候，向方法的小括号传参数，传递进去的其实是数组的地址值。！！！！！！

public static void main(String[] args) {
    int[] array = {10, 20, 30, 40, 50};

    System.out.println(array); //地址值

    printArray(array); //传递进去的，其实就是array当中保存的地址值
    System.out.println("=============AAA=============");
    printArray(array);
    System.out.println("=============BBB=============");
}

/*
返回值类型：只是进行打印而已，不需要计算，也没有结果，用void
方法名称：printArray
参数列表：必须给我数组，我才能打印其中的元素 , int[] array
 */
public static void printArray(int[] array) {
    System.out.println("printArray方法收到的参数是：");
    System.out.println(array); //地址值
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}

数组作为返回值

一个方法可以有0，1，多个参数。但是只能有0或者1个返回值，不能由多个返回值。如果希望一个方法当中产生了多个结果数据进行返回，怎么办？解决方案：使用一个数组作为返回值类型即可

public static void main(String[] args) {
        int[] result = calculate(10,20,30);
        System.out.println("main方法接收到的返回值数组是:");
        System.out.println(result);

        System.out.println("总和:" + result[0]);
        System.out.println("平均数:" + result[1]);
    }

    public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c; //总和
        int avg = sum / 3; //平均数
        //两个结果都希望进行返回
//        return sum,avg        //错误

        // 需要一个数组，数组可以保存多个结果
       /* int[] array = new int[2];
        array[0] = sum; //总和
        array[1] = avg; //平均数*/

       int[] array = {sum, avg};
        System.out.println("calculate方法内部数组是：");
        System.out.println(array); //地址值

       return array;

参数返回值

任何数据类型都可以作为方法的参数类型，或者返回值类型。

数组作为方法的参数时，传递进去的其实是数组的地址值 数组作为方法的返回值时，返回的其实也是数组的地址值

面向对象

概述

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做这件事。

面向对象三大特征：封装，继承，多态。。。

// 面向过程与面向对象的区别
public static void main(String[] args) {
    int[] array = {10, 20, 30, 40, 50};

    // 要求打印格式为：[10, 20, 30, 40, 50]
    // 使用面向过程，每一个过程都要亲力亲为。
    System.out.print("[");
    for (int i = 0; i < array.length; i++) {
        if (i == array.length-1) { //如果是最后一个元素
            System.out.println(array[i] + "]");
        } else { //如果不是最后一个元素
        System.out.print(array[i] + ", ");
        }
    }
    System.out.println("===================");

    // 使用面向对象
    // 找一个JDK给我们提供好的Arrays类.
    // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
    System.out.println(Arrays.toString(array));
}

如何创建对象

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

如何创建对象 1.导包：也就是指出需要使用的类在什么位置。 import 包名称.类名称； import cn.itcast.day06.demo01.Student; import是关键字对于和当前类属于同一个包的情况，可以省略导包语句不写。 Demo02和类Student在一起，就不用写了

2.创建： 类名称对象名 = new 类名称(); Student stu = new Student(); //根据Student类创建了一个名为stu的对象

3.使用，分为两种情况： 使用成员变量：对象名.成员变量名 使用成员方法：对象名.成员方法名(参数) （也就是，想用谁，就用对象名.谁）

注意事项：如果成员变量没有进行赋值，呢么将会有一个默认值，规则和数组一样。如果是整数类型：默认为0 如果是浮点类型，默认为0.0 如果是字符类型，默认为'\u0000' 如果是boolean，默认为false值如果是引用类型，默认为null

“学生”

定义一个类：“学生” 用来模拟“学生”事物，其中就有两个组成部分：

属性（是什么）：姓名年龄 ... 行为（能做什么）：吃饭睡觉学习

对应到JAVA的类当中：

成员变量（属性）：（数据类型变量名称） String name; //姓名 int age; // 年龄 成员方法（行为）： public void eat() {} // 吃饭 public void sleep() {} // 睡觉 public void study() {} // 学习

注意事项: 1.成员变量是直接定义在类当中的，在方法外边 2.成员方法不要写static关键字。

// 定义一个学生类
public class Student {
    // 成员变量
    String name; //姓名
    int age;    // 年龄

    // 成员方法
    public void eat() {
        System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
    public void study() {
        System.out.println("学习");
    }
}

根据类创建使用对象

public static void main(String[] args) {
    // 1.导包。
    // 我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写

    // 2.创建，格式：
    // 类名称 对象名 = new 类名称();
    // 根据Student类创建了一个名为stu的对象。
    Student stu = new Student();

    // 3.使用其中的成员变量，格式：
    // 对象名.成员变量名
    System.out.println(stu.name); //默认值 null
    System.out.println(stu.age); // 默认值 0
    System.out.println("================");

    // 改变对象当中的成员变量数值内容
    stu.name = "张三";
    stu.age = 18;
    System.out.println(stu.name);
    System.out.println(stu.age);
    System.out.println("================");

    // 4.使用对象的成员方法，格式：
    // 对象名.成员方法名(参数)
    stu.eat();
    stu.sleep();
    stu.study();
}

”Phone“

定义一个类，用来模拟“手机”事物

属性：品牌、价格、颜色行为：打电话、发短信

对应到类当中：成员变量(属性)： String brand; //品牌 double price; //价格 String color; //颜色成员方法(行为)： public void call(String who) {} //打电话 public void sendMessage() {} //群发短信

public class Phone {

    // 成员变量
    String brand; //品牌
    double price; //价格
    String color; //颜色

    // 成员方法
    public void call(String who) {
        System.out.println("给" + who + "打电话");
    }

    public void sendMessage() {
        System.out.println("群发短信");
    }
}

// Demo01PhoneOne
public static void main(String[] args) {
    // 根据Phone类创建一个名为one的对象。格式：
    // 类名称 对象名 = new 类名称();
    Phone one = new Phone();
    System.out.println(one.brand); //null
    System.out.println(one.price); //0.0
    System.out.println(one.color); //null
    System.out.println("==============");

    one.brand = "苹果";
    one.price = 8388.0;
    one.color = "黑色";
    System.out.println(one.brand); //苹果
    System.out.println(one.price); //8388.0
    System.out.println(one.color); //黑色
    System.out.println("==============");

    // 使用成员方法，格式：
    // 对象名.方法名称(参数);
    one.call("乔布斯");
    one.sendMessage();

// Demo02PhoneTwo
public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand); //null
        System.out.println(one.price); //0.0
        System.out.println(one.color); //null
        System.out.println("==============");

        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "黑色";
        System.out.println(one.brand); //苹果
        System.out.println(one.price); //8388.0
        System.out.println(one.color); //黑色
        System.out.println("==============");

        one.call("乔布斯");
        one.sendMessage(); //群发短信
        System.out.println("==============");

        Phone two = new Phone();
        System.out.println(two.brand); //null
        System.out.println(two.price); //0.0
        System.out.println(two.color); //null
        System.out.println("==============");

        two.brand = "三星";
        two.price = 5999.0;
        two.color = "蓝色";
        System.out.println(two.brand); //三星
        System.out.println(two.price); //5999.0
        System.out.println(two.color); //蓝色
        System.out.println("==============");

        two.call("欧巴");
        two.sendMessage();
    }

public static void main(String[] args) {
    Phone one = new Phone();
    System.out.println(one.brand); //null
    System.out.println(one.price); //0.0
    System.out.println(one.color); //null
    System.out.println("==============");

    one.brand = "苹果";
    one.price = 8388.0;
    one.color = "黑色";
    System.out.println(one.brand); //苹果
    System.out.println(one.price); //8388.0
    System.out.println(one.color); //黑色
    System.out.println("==============");

    one.call("乔布斯");
    one.sendMessage(); //群发短信
    System.out.println("==============");

    // 将one当中保存的地址值赋值给two
    Phone two = one;
    System.out.println(two.brand); //null -->苹果
    System.out.println(two.price); //0.0  -->8388.0
    System.out.println(two.color); //null -->黑色
    System.out.println("==============");

    two.brand = "三星";
    two.price = 5999.0;
    two.color = "蓝色";
    System.out.println(two.brand); //三星
    System.out.println(two.price); //5999.0
    System.out.println(two.color); //蓝色
    System.out.println("==============");

    two.call("欧巴");
    two.sendMessage();
}

param是参数的意思任何数据类型都可以作为方法的参数或者返回值那么能不能用自定义的Phone这个类作为方法的参数类型

！！！！！！！！！！！！！！！！！当一个对象作为参数，传递到方法中时，实际上传递进去的是对象的地址值。

public static void main(String[] args) {
    Phone one = new Phone();
    one.brand = "苹果";
    one.price = 8388.0;
    one.color = "土豪金";

    method(one); //传递进去的参数其实就是地址值
    System.out.println(one);
}

public static void method(Phone param) {
    System.out.println(param.brand); //苹果
    System.out.println(param.price); //8388.0
    System.out.println(param.color); //土豪金
}

public static void main(String[] args) {
    Phone two = getPhone();
    System.out.println(two.brand); //苹果
    System.out.println(two.price); //8388.0
    System.out.println(two.color); //玫瑰金

}

public static Phone getPhone() {
    Phone one = new Phone();
    one.brand = "苹果";
    one.price = 8388.0;
    one.color = "玫瑰金";
    return one;
}

局部变量和全局变量

1.定义的位置不一样【重点】 局部变量：在方法的内部 成员变量：在方法的外部，直接写在类当中

2.作用范围不一样【重点】 局部变量：只有方法当中才可以使用，出了方法就不能再用 成员变量：整个类全都可以通用

3.默认值不一样【重点】 局部变量：没有默认值，如果想要使用，必须手动进行赋值 成员变量：如果没有赋值，会有默认值，规则和数组一样

4.内存的位置不一样【重点】 局部变量：位于栈内存 成员变量：位于堆内存

5.生命周期不一样【重点】 局部变量：随着方法进栈而诞生 随着方法出栈而消失 成员变量：随着对象创建而诞生 随着对象被垃圾回收而消失

public class Demo01VariableDifference {

    String name; //成员变量

    public void methodA() {
        int num = 20; //局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param) {    //方法的参数就是局部变量
        // 参数在方法调用的时候，必然会被赋值的。      ！！！！！！
        System.out.println(param);

        int age;    //局部变量
//        System.out.println(age);    //局部变量没有赋值不能使用，没有默认值
//        System.out.println(num);    //错误写法!
        System.out.println(name);
    }

封装性

面向对象三大特征：封装，继承，多态

封装性在Java当中的体现： 1.方法就是一种封装 2.关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见。

public static void main(String[] args) {
    int[] array = {5, 15, 25, 20, 100};

    int max = getMax(array);
    System.out.println("最大值为:" + max);
}

// 给我一个数组，还你一个最大值
public static int getMax(int[] array) {
    int max = array[0];
    for (int i =1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max;
}

Getter/Setter

问题描述：我们定义Person的年龄时，无法阻止不合理的数值被设置进来。解决方案：用private关键字将需要保护的成员变量进行修饰。

一旦使用private进行修饰，那么本类当中仍然可以随意访问。 但是！超出了本类范围之外就不能直接访问了。

间接访问private成员变量，就是定义一对Getter/Setter方法

必须叫setXxx，或者是getXxx命名规则。 对于Getter来说，不能有参数，返回值类型与成员变量对应。 对于Setter来说，不能有返回值，参数类型与成员变量对应。

Person类

public class Person {

    String name; //姓名
    private int age; //年龄

    public void show() {

        System.out.println("我叫" + name + ",年龄" + age);
    }

    // 这个成员方法：专门用来向age设置数据
    // set必须有参数无返回，参数类型要和需要set的变量保持一致，名称规则：set+变量名称首字母大写
    public void setAge(int num) {
        if (num < 100 && num>=0 ) { // 如果是合理情况
            age = num;
        } else {
            System.out.println("数据不合理！");
        }
    }

    // 这个成员方法：专门用来获取age的数据
    // get必须没有参数，有返回值，返回值类型跟成员变量要对应，名称规则：get+变量名称首字母大写
//    public int getAge() {
//        return age;
//    }

public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "张三";
//        person.age = 18; // 直接访问private内容，错误写法！
        person.setAge(-20);
//        person.setAge(20);
        person.show();
    }

Student类

对于基本类型当中的boolean值，Getter方法一定要写成isXxx，而setXxx规则不变

public class Student {

    private String name; //姓名
    private int age;     //年龄
    private boolean male; //是不是男的

    public void setMale(boolean b) {
        male = b;
    }

    public boolean isMale() {
        return male;
    }

    public void setName(String str) {
        name = str;
    }

    public String getName() {
        return name;
    }

    public void setAge(int num) {
        age = num;
    }

    public int getAge() {
        return age;
    }
}

public static void main(String[] args) {
    Student stu = new Student();

    stu.setName("鹿晗");
    stu.setAge(20);
    stu.setMale(true);

    System.out.println("姓名：" + stu.getName());
    System.out.println("年龄：" + stu.getAge());
    System.out.println("是不是男的：" + stu.isMale());
}

this关键字

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，会优先使用局部变量。如果需要访问本类当中的成员变量，需要使用格式： this.成员变量名

"通过谁调用的方法，谁就是this。"

public class Person {

    String name; //我自己的名字

    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + ",你好。我是" + this.name);
        System.out.println(this);
    }
}

public static void main(String[] args) {

    Person person = new Person();
    // 我自己的名字
    person.name = "王健林";
    person.sayHello("王思聪");

    System.out.println(person); //地址值
}

结果

王思聪,你好。我是王健林 cn.itcast.day06.demo04.Person@1e643faf cn.itcast.day06.demo04.Person@1e643faf

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，趋势就是在调用构造方法。格式： public 类名称(参数类型，参数名称) { 方法体 }

注意事项： 1.构造方法的名称，必须和所在的类名称完全一样，就连大小写也要一样。 2.构造方法不要写返回值类型，连void都不写 3.构造方法不能return一个具体的返回值 4.如果没有编写任何构造方法，那么编译器会默认赠送一个构造方法，没有参数、方法体什么事情都不做。 public Student() {} 5.一旦编写了至少一个构造方法，那么编译器将不再赠送. 6.构造方法也是可以进行重载的。重载：方法名称相同，参数列表不同。

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 无参数的构造方法
    public Student() {
        System.out.println("无参构造方法执行啦！");
    }

    // 全参数的构造方法
    public Student(String name,int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name;
        this.age = age;
    }

    // Getter/Setter
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public static void main(String[] args) {

    Student stu1 = new Student();   //无参构造
    System.out.println("==================");

    Student stu2 = new Student("张三",20);    //全参构造
    System.out.println("姓名：" + stu2.getName() + ",年龄：" + stu2.getAge());
    // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setxxx方法
    stu2.setAge(21);
    System.out.println("姓名：" + stu2.getName() + ",年龄：" + stu2.getAge());

}

结果

无参构造方法执行啦！

全参构造方法执行啦！姓名：张三,年龄：20 姓名：张三,年龄：21

类

一个标准的类通常要满足下列四个组成部分：

1.所有的成员变量都要使用private进行修饰。 2.为每一个成员变量编写一对 Getter/Setter 3.编写一个无参数的构造方法 4.编写一个全参数的构造方法

标准的类：Java Bean

public class Student {

    private String name; //姓名
    private int age; //年龄

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {this.name = name;}

    public String getName() {return name;}

    public void setAge(int age) {this.age = age;}

    public int getAge() {return age;}

public static void main(String[] args) {

    Student stu1 = new Student();
    stu1.setName("张三");
    stu1.setAge(20);
    System.out.println("姓名：" + stu1.getName() + "，年龄:" + stu1.getAge());
    System.out.println("===================");

    Student stu2 = new Student("李四",20);
    System.out.println("姓名：" + stu1.getName() + "，年龄:" + stu1.getAge());
    stu1.setAge(21);
    System.out.println("姓名：" + stu1.getName() + "，年龄:" + stu1.getAge());
}

结果

姓名：张三，年龄:20

姓名：张三，年龄:21

Scanner类

创建使用

Scanner类的功能：可以实现键盘输入数据，到程序当中。

引用类型的一般使用步骤：

1.导包 import 包路径.类名称; 如果需要使用的目标类，和当前的类在同一个包下，则可以省略导包语句不写。只有java.lang包下的内容不需要导包，其他的包都需要import语句。

2.创建 类名称对象名 = new 类名称();

3.使用 对象名.成员方法名()

获取键盘输入的一个int数字：对象名.成员方法名() : int num = sc.nextInt(); 获取键盘输入的一个字符串：对象名.成员方法名() : String str = sc.next();

import java.util.Scanner; //1.导包
public static void main(String[] args) {

    //2.创建
    //备注：System.in代表从键盘输入
    Scanner sc = new Scanner(System.in);

    //3.获取键盘输入的int数字
    int num = sc.nextInt();
    System.out.println("输入的int数字是：" + num);

    //4.获取键盘输入的字符串
    String str = sc.next();
    System.out.println("输入的字符串是：" + str);
}

练习

1.题目：键盘输入两个int数字，并且求出和值

思路：
1.既然要键盘输入，就要用Scanner
2.Scanner的三个步骤：导包，创建，使用
3.需要的是两个数字，所以需要调用两次nextInt()方法
4.得到了两个数字，就需要加在一起
5.将结果打印输出

import java.util.Scanner; //1.导包
public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入第一个数字:");
    int a = sc.nextInt();
    System.out.println("请输入第二个数字:");
    int b = sc.nextInt();

    int result = a + b;
    System.out.println("结果是：" + result);
}

2.键盘输入三个int数字，然后求出最大值

思路：
1.既然要键盘输入，就要用Scanner
2.Scanner的三个步骤：导包，创建，使用
3.需要的是三个数字，所以需要调用三次nextInt()方法，得到三个int变量
4.既然是三个数字，无法同时判断三个数字，应转换成为两个步骤
    4.1 首先判断前两个数字当中谁最大，拿到前两个数字的最大值
    4.2 拿着前两个当中的最大值，再和第三个比较，得到三个数字当中的最大值
5.打印最终结果

import java.util.Scanner; //1.导包
public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入第一个数字:");
    int a = sc.nextInt();

    System.out.println("请输入第二个数字:");
    int b = sc.nextInt();

    System.out.println("请输入第三个数字:");
    int c = sc.nextInt();

    // 首先得到前两个数字当中的最大值
    int temp = a > b ? a : b;
    int max = temp > c ? temp : c;
    System.out.println("最大值是：" + max);
}

匿名对象

创建对象的标准格式：
类名称 对象名 = new 类名称();

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();

注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象
使用建议：如果确定有一个对象只能使用唯一的一次，就可以使用匿名对象。

首先创建一个Person类

public class Person {
    String name;
    public void showName() {
        System.out.println("我叫：" + name);
    }
}

public static void main(String[] args) {
    // 左边的one就是对象的名字
    Person one = new Person();
    one.name = "张三"; //我叫张三
    one.showName();
    System.out.println("==================");

    // 匿名对象
    new Person().name = "李四";
    new Person().showName(); // ？  null
}

import java.util.Scanner;
public static void main(String[] args) {
        // 普通使用方式
//        Scanner sc = new Scanner(System.in);
//        int num = sc.nextInt();

        // 使用匿名对象
//        int num = new Scanner(System.in).nextInt();
//        System.out.println("输入的是：" + num);

        // 使用一般写法传入参数
//        Scanner sc = new Scanner(System.in);
//        methodParam(sc);

        // 使用匿名对象来进行传参
//        methodParam(new Scanner(System.in));

        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("输入的是：" + num);

    }

    public static void methodParam(Scanner sc) {
        int num = sc.nextInt();
        System.out.println("输入的是：" + num);
    }

    public static Scanner methodReturn() {
//        Scanner sc = new Scanner(System.in);
//        return sc;

        return new Scanner(System.in);
    }

随机数Random

Random类用来生成随机数字，使用起来也是三个步骤

1.导包
import java.util.Random;

2.创建
Random r = new Random(); //小括号留空即可

3.使用
获取一个随机的int数字(范围是int所有范围，有正负两种)：int num = r.nextInt()
获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
实际上代表的含义是 [0,3),也就是0~2

产生一个随机数

import java.util.Random;
public static void main(String[] args) {

        Random r = new Random();

        int num = r.nextInt();
        System.out.println("随机数是：" + num);

产生100个10以内的随机数

import java.util.Random;
public static void main(String[] args) {

        Random r = new Random();

        for (int i = 0; i < 100; i++) {
            int num = r.nextInt(10);  //范围实际上是0~9
            System.out.println(num);
        }
    }

题目要求：根据int变量的值，来获取随机数字，范围是[1,n]，可以取到1也可以取到n。

思路:
1.定义一个int变量n，随意赋值
2.要使用Random：三个步骤，导包，创建，使用
3.如果写10，那么就是0~9，而想要的是1~10，可以发现：整体+1即可

import java.util.Random;
public static void main(String[] args) {

        int n = 5;
        Random r = new Random();

        for (int i = 0; i < 100; i++) {
            //本来范围是[0,n)，整体+1之后变成了[1,n+1),也就是[1,n]
            int result = r.nextInt(n) +1;
            System.out.println(result);
        }
    }

题目：用代码模拟猜数字的小游戏。

思路：
1.首先需要产生一个随机数字，并且一旦产生不再发生变化。用Random的nextInt()方法
2.需要键盘输入，所以用到了Scanner
3.获取键盘输入的数字，用Scanner当中的nextInt方法
4.已经得到了两个数字，判断（if）一下：
    如果太大，提示太大，并且重试
    如果太小，提示太小，并且重试
    如果猜对了，游戏结束
5.重试就是再来一次，循环次数不确定，用一个while(true)

import java.util.Random;
import java.util.Scanner;
public static void main(String[] args) {

        Random r = new Random();
        int randomNum = r.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        System.out.println("按任意数字键开始游戏，如想退出游戏，请按数字0");
        int i = sc.nextInt();

        while (i != 0) {
            System.out.println("请输入你猜测的数字：");
            int guessNum = sc.nextInt();

            if(randomNum < guessNum) {
                System.out.println("太大了，请重试");
            } else if (randomNum > guessNum) {
                System.out.println("太小了，请重试");
            } else {
                System.out.println("恭喜你，猜对了!");
                break; //如果猜中，不在重试
            }
        }

        System.out.println("游戏结束");
    }

集合

数组的缺点

题目：要求定义一个数组，用来存储3个Person对象。

数组有一个缺点，一旦创建，程序运行期间长度不可发生改变

首先创建一个Person类

public class Person {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}
}

public static void main(String[] args) {
        // 首先创建一个长度为3的数组，里面用来存放Person类型的对象。
        Person[] array = new Person[3];
//        System.out.println(array[0]);
//        System.out.println(array[1]);
//        System.out.println(array[2]);

        Person one = new Person("张三",18);
        Person two = new Person("李四",28);
        Person three = new Person("王五",28);

        // 将one当中的地址值复制到数组的0号元素位置
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]); //地址值
        System.out.println(array[1]); //地址值
        System.out.println(array[2]); //地址值

//        Person person = array[1];
//        System.out.println(person.getName()); //李四
        System.out.println(array[1].getName()); //李四
    }

集合的创建

数组的长度是可以发生改变。但是ArrayList集合的长度是可以任意变化的。

对于ArrayList来说，有一个尖括号 <E> 代表泛型。泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。注意：泛型只能是引用类型，不能是基本类型

注意事项：对于ArrayList集合来说，直接打印得到的不是地址值，而是内容如果内容是空，得到的是空的中括号：[]

import java.util.ArrayList;
public static void main(String[] args) {
        // 创建了一个ArrayList集合，集合的名称是list，里面全都是String字符串类型的数据。
        // 备注：从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list); //[]

        // 想集合当中添加一些数据，需要用到add方法。
        list.add("张三");
        System.out.println(list); // 张三

        list.add("李四");
        list.add("王五");
        list.add("赵六");
        System.out.println(list); // 张三, 李四, 王五, 赵六

//        list.add(100);  //错误写法！因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行

    }

集合的使用方法

import java.util.ArrayList;
public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        System.out.println(list); //[]

        //向集合中添加元素：add
        boolean flag = list.add("柳岩");
        System.out.println(list); // 柳岩
        System.out.println("添加动作是否成功：\n" + flag); // 成功

        list.add("高圆圆");
        list.add("赵又廷");
        list.add("李小璐");
        list.add("贾乃亮");
        System.out.println(list); //[柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮]

        // 从集合中获取元素：get
        String name = list.get(2);
        System.out.println("第2号索引位置：" + name); //第2号索引位置：赵又廷

        // 从集合中删除元素: remove
        String whoRemove = list.remove(3); //被删掉的人是：李小璐
        System.out.println("被删掉的人是：" + whoRemove); //[柳岩, 高圆圆, 赵又廷, 贾乃亮]
        System.out.println(list);

        // 获取集合的尺寸
        int size = list.size();
        System.out.println("集合的长度是：" + size); //集合的长度是：4
    }

遍历集合

import java.util.ArrayList;

public class Demo04ArrayListEach {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

集合储存

如果希望向集合ArrayList当中储存基本类型数据，必须使用基本类型对应的"包装类"。

基本类型    包装类（引用类型，包装类全都位于java.long包下）
byte        Byte
short       Short
int         Integer     【特殊】
long        Long
float       Float
double      Double
char        Character   【特殊】
boolean     Boolean

从JDK1.5+开始，支持自动装箱，自动拆箱。

自动装箱：基本类型 ---> 包装类型     例如 int ---> Integer
自动拆箱：包装类型 ---> 基本类型     例如 Integer ---> int

public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        // 错误写法！泛型只能是引用类型，不能是基本类型
//        ArrayList<int> list2 = new ArrayList<int>();

        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        System.out.println(list); //[100,200,300]

        int num = list.get(1);
        System.out.println("第1号元素是：" + num); //200

练习

1

题目: 生成6个1~33之间的随机整数，添加到集合，并遍历集合

思路：
1.需要存储6个数字，创建一个集合，<Integer>
2.产生随机数需要用到Random
3.用循环6次来产生6个随机数字，for循环
4.循环内调用r.nextInt(int n)方法，参数时33，0~32，整体+1，才是1~33
5.把数字添加到集合中，add
6.遍历集合，for，size，get

import java.util.ArrayList;
import java.util.Random;
public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    Random r = new Random();
    for (int i = 0; i < 6; i++) {
        int num = r.nextInt(33) + 1;
        list.add(num);
    }
    // 遍历集合
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

2

题目：
自定义4个学生对象，添加到集合，并遍历

思路：
1.自定义Student学生类，四个部分。
    所有成员变量全用private修饰
    要有无参构造
    要有全参构造
    Getter/Setter方法
2.创建一个集合，用来存储学生对象。泛型<Student>
3.根据类创建四个学生对象。并且复制。
4.将4个学生对象添加到集合当中：add
5.遍历集合，for，size，get

1.首先创建一个学生类

public class Student {

    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}

import java.util.ArrayList;
public static void main(String[] args) {
    ArrayList<Student> list = new ArrayList<>();

    Student one = new Student("张三",20);
    Student two = new Student("李四",21);
    Student three = new Student("王五",22);
    Student four = new Student("赵六",23);

    list.add(one);
    list.add(two);
    list.add(three);
    list.add(four);

    // 遍历集合
    for (int i = 0; i < list.size(); i++) {
        Student stu = list.get(i);
        System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
    }
}

集合类型作为参数

题目: 定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}配合，使用@分隔每个元素。格式参照{元素@元素@元素}。

System.out.println(list); [10,20,30] 定义方法printArrayList(list)； {10@20@30}

import java.util.ArrayList;
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("张三");
    list.add("李四");
    list.add("王五");
    list.add("赵六");
    System.out.println(list); //[张三, 李四, 王五, 赵六]

    printArrayList(list);
}

/*
定义方法的三要素
1.返回值类型：只是进行打印而已，没有运算，没有结果，void
2.方法名称：printArrayList
3.参数列表：ArrayList
 */
public static void printArrayList(ArrayList<String> list){
    // {10@20@30}
    System.out.print("{");
    for (int i = 0; i < list.size(); i++) {
        String name = list.get(i);
        if (i == list.size() - 1) {
            System.out.println(name + "}");
        } else{
        System.out.print(name + "@");
        }
    }
}
结果：
    [张三, 李四, 王五, 赵六]
    {张三@李四@王五@赵六}

集合类型作为返回值

题目：用一个大集合存入20个随机数字，然后筛选其中的偶数集合，放到小集合当中。要求使用自定义的方法来是先筛选。

分析：
1.需要创建一个集合，用来存储int数字：<Integer>
2.随机数字用Random，nextInt
3.循环20次把随机数字放入大集合随机数字：for循环，add方法
4.定义一个方法，用来进行筛选
5.根据大集合，筛选符合要求的元素，得到小集合
三要素：
返回值类型： ArrayList小集合（里面元素个数不确定）
方法名称：   getSmallList
参数列表：   ArrayList大集合（装着20个数字）
6.判断是偶数：num%2 == 0
7.如果是偶数就放到小集合当中，否则就不写

public static void main(String[] args) {
    ArrayList<Integer> bigList = new ArrayList<>();
    Random r = new Random();
    for (int i = 0; i < 20; i++) {
        int num = r.nextInt(100) + 1; //1~100
        bigList.add(num);
    }

    ArrayList<Integer> smallList = getSmallList(bigList);

    System.out.println("偶数总共有多少个" + smallList.size());
    for (int i = 0; i < smallList.size(); i++) {
        System.out.println(smallList.get(i));
    }
}

    // 这个方法接收大集合参数，返回小集合结果
    public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
        // 创建一个小集合，用来装偶数结果
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
            int num = bigList.get(i);
            if (num%2 == 0){
                smallList.add(num);
            }
        }

        return smallList;
    }

常见API

String类

java.lang.String类代表字符串。 API当中说，Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。其实就是说程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也是）

字符串的特点： 1.字符串的内容，永不可变。是一个常量【重点】 2.正是因为字符串不可改变，所以字符串是可以共享使用的。 3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式。三种构造方法： public String()：创建一个空白字符串，不含有任何内容。 public String(char[] array)：根据字符数组的内容，来创建对应的字符串。 public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。

一种直接创建： String str = "Hello" // 右边直接用双引号

注意：直接写上双引号，就是字符串对象。

各种创建方法

空参构造

// 使用空参构造
String str1 = new String(); //小括号留空，说明字符串什么内容也没有
System.out.println("第一个字符串：" + str1);

根据字符数组创建字符串

char[] charArray = {'A','B','C'};
String str2 = new String(charArray);
System.out.println("第二个字符串：" + str2);

根据字节数组创建字符串

byte[] byteArray = {97,98,99};
String str3 = new String(byteArray);
System.out.println("第三个字符串：" + str3);

直接创建

String str4 = "Hello";
System.out.println("第4个字符串：" + str4);

字符串常量池

字符串常量池：程序中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说，==是进行数值的比较。对于引用类型来说，==是进行地址值的比较。

public static void main(String[] args) {
    String str1 = "abc";
    String str2 = "abc";

    char[] charArray = {'a','b','c'};
    String str3 = new String(charArray);

    System.out.println(str1 == str2); //true
    System.out.println(str1 == str3); //false
    System.out.println(str2 == str3); //false

}

内存解释:

equals 比较方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

public boolean equals(Object obj): 参数可以是任何对象，只有参数是一个字符串并且内容相同时才会给ture，否则返回false 注意事项： 1.任何对象都能使用Object接收。 2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样 3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面。推荐： "abc".equals(str) 不推荐： str.equals("abc")

public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较

 public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H','e','l','l','o'};
        String str3 = new String(charArray);

        System.out.println(str1.equals(str2)); //true
        System.out.println(str2.equals(str3)); //true
        System.out.println(str3.equals("Hello")); //true
        System.out.println("Hello".equals(str1)); //true
        System.out.println("=======================");

        String str5 = null;
        System.out.println("abc".equals(str5)); //推荐：false
//        System.out.println(str5.equals("abc")); //不推荐：空指针异常NullPointerException

        System.out.println("==================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); //false
        System.out.println(strA.equalsIgnoreCase(strB)); //true

字符串中与获取相关的方法

获取字符串长度

// public int length(): 获取字符串当中含有的字符个数，拿到字符长度

// 获取字符串的长度
int length = "sajkfhajdslkdjakfdjgs".length();
System.out.println("字符串的长度是：" + length);

拼接字符串

// public String concat(String str): 将当前字符串和参数字符串拼接成为返回值 【新的字符串】。

String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
//        String str3 = str1 + str2;
        System.out.println(str1); // Hello
        System.out.println(str2); // World
        System.out.println(str3); // HelloWorld.新的字符串

获取指定索引位置的单个字符

// public char charAt(int index): 获取指定索引位置的单个字符（索引从0开始）。

// 获取指定索引位置的单个字符
char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是：" + ch);
        System.out.println("====================");

查找参数字符串在原字符串当中出现的第一次索引位置

// public int indexOf(String str): 查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

// 查找赞数字符串在原本字符串当中出现的第一次索引
        // 如果根本没有，返回 -1。
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值的位置：" + index);

字符串的截取方法

public String substring(int index): 截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin,int end): 截取一个范围，从begin开始，到end结束，中间的字符串
备注：[begin,end), 包含左边，不包含右边

public static void main(String[] args) {
    String str1 = "HelloWorld";
    String str2 = str1.substring(5);
    System.out.println(str1); // HelloWorld
    System.out.println(str2); // World，新字符串
    System.out.println("==================");

    String str3 = str1.substring(4,7);
    System.out.println(str3); //oWo
    System.out.println("==================");

    // 下面这种写法，字符串的内容仍然是没有改变的
    // 下面有两个字符串。"Hello","Java"
    // strA当中保存的是地址值
    // 本来地址值是Hello的0x666
    // 后来地址值变成了Java的0x999
    String strA = "Hello";
    System.out.println(strA); // Hello
    strA = "Java";
    System.out.println(strA); // Java

String当中与转换相关的常用方法

转化为字符数组

public char[] toCharArray();  将当前的字符串拆分成字符数组作为返回值。

// 转化成为字符数组
char[] chars = "Hello".toCharArray();
System.out.println(chars[0]); //H
System.out.println(chars.length); //5

转换为字节数组

public byte[] getBytes();     获得当前字符串底层的字节数组。

// 转化成为字节数组
byte[] bytes = "abc".getBytes();
System.out.println(bytes[0]);
for (int i = 0; i < bytes.length; i++) {
    System.out.println(bytes[i]);
}

替换字符串

public String replace(CharSequence oldString, CharSequence newString);
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果 新字符串。
备注：CharSequence意思就是说可以接收字符串类型。

String str1 = "How do you do?";
String str2 = str1.replace("o", "*");
System.out.println(str1); //How do you do?
System.out.println(str2); //H*w d* y*u d*?

分割字符串的方法

public String[] split(String regex);  按照参数的规则，将字符串切分成若干部分。
    
/*注意事项:
split方法的参数其实是一个“正则表达式”，
今天要注意：如果按照英文句点“.”进行切分，必须写成“\\.(两个反斜杠)”
*/

 public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc,d";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("=================");

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("=================");

        String str3 = "XXX.YYY.ZZZ";
//        String[] array3 = str3.split("."); //
//        把"."修改为"\\."
        String[] array3 = str3.split("\\.");
        System.out.println(array3.length); //
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }

练习题

1

题目：
定义一个方法，把数组{1，2，3}按照指定格式拼接成一个字符串。参照格式如下: [word1#word2#word3].

分析:
1.首先准备一个int数组，内容是1，2，3。
2.定义一个方法，用来将数组变成字符串
三要素：
返回值类型：String
方法名称：fromArrayToString
参数列表：int[]
3.方法体:
格式：[word1#word2#word3]
用到for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
4.调用方法得到返回值，并打印返回值

public static void main(String[] args) {
    int[] array = {1,2,3};
    String result = fromArrayToString(array);
    System.out.println(result);
}

public static String fromArrayToString(int[] array) {
    String str = "[";
    for (int i = 0; i < array.length; i++) {
        if (i == array.length - 1) {
            str += "word" + array[i] + "]";
        } else {
            str += "word" + array[i] + "#";
        }
    }
    return  str;
}

2

题目：
键盘输入一个字符串，并且统计其中各种字符出现的次数。
种类有：大写字母、小写字母、数字、其他

分析：
1.既然用到键盘输入，肯定是Scanner
2.键盘输入的是字符串，那么String sc = sc.next();
3.定义四个变量，分别代表自各字符的出现次数
4.需要对字符串一个字、一个字的检查，String --> char[]，方法就是toCharArray
5.遍历char[]型字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作
6.打印输出四个变量，分别代表四种字符的出现次数。

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串：");
    String input = sc.next();   // 获取键盘输入的字符串

    int countUpper = 0; // 大写字母
    int countlower = 0; // 小写字母
    int countNumber = 0; // 数字
    int countOther = 0; // 其他

    char[] charArray = input.toCharArray();
    for (int i = 0; i < charArray.length; i++) {
        char ch = charArray[i]; // 当前单个字符
        if ('A' <= ch && ch <= 'Z') {
            countUpper++;
        } else if ('a' <= ch && ch <= 'z') {
            countlower++;
        } else if ('0' <= ch && ch <= '9') {
            countNumber++;
        } else {
            countOther++;
        }
    }

    System.out.println("大写字母有：" + countUpper + "个");
    System.out.println("小写字母有：" + countlower + "个");
    System.out.println("数字有：" + countNumber + "个");
    System.out.println("其他字符有：" + countOther + "个");
}

为什么遇到空格就终止判断了？怎么解决？

Arrays类

概述

java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组创建的操作。

使用方法

public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组元素进行排序。

备注： 1.如果是数字，sort默认按升序从小到大排列 2.如果是字符串。sort默认按字母升序 3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）

import java.util.Arrays;
public static void main(String[] args) {
    int[] intArray = {10,20,30};
    // 将int[]数组按照默认格式变成字符串
    String intStr = Arrays.toString(intArray);
    System.out.println(intStr); // [10,20,30]

    int[] array1 = {2,1,3,10,6};
    Arrays.sort(array1);
    for (int i = 0; i < array1.length; i++) {
        System.out.print(array1[i] + ",");
    }
    System.out.println(Arrays.toString(array1));// [1, 2, 3, 6, 10]

    String [] array2 = {"bbb","aaa","ccc"};
    Arrays.sort(array2);
    System.out.println(Arrays.toString(array2));// [aaa, bbb, ccc]
}
结果：
    [10, 20, 30]
    1,2,3,6,10,[1, 2, 3, 6, 10]
    [aaa, bbb, ccc]

练习

题目：
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

import java.util.Arrays;
public static void main(String[] args) {
    String str = "aksjdh4wD898dhfj3H";

    // 如何进行升序排列
    // 必须是一个数组，才能用Arrays.sort方法
    // String --> 数组，用toCharArray
    char[] chars = str.toCharArray();
    Arrays.sort(chars); // 对字符数组进行升序排列

    // 需要倒序排列
    for (int i = chars.length - 1; i >= 0; i--) {    //fori 是正序，forr是倒序
        System.out.println(chars[i]);
    }
}

数学Math类

java.util.Math是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

使用方法

public static double abs(double num);   获取绝对值。
public static double ceil(double num);  向上取整。
public static double floor(double num); 向下取整。
public static long round(double num);   四舍五入
    Math.PI 代表近似的圆周率常量

public static void main(String[] args) {
    // 获取绝对值
    System.out.println(Math.abs(3.14)); // 3.14
    System.out.println(Math.abs(0)); // 0
    System.out.println(Math.abs(-2.5)); // 2.5
    System.out.println("=============");

    // 向上取整
    System.out.println(Math.ceil(3.9)); //4.0
    System.out.println(Math.ceil(3.1)); //4.0
    System.out.println("=============");

    // 向下取整，抹零
    System.out.println(Math.floor(30.1)); //30.0
    System.out.println(Math.floor(30.9)); //30.0
    System.out.println(Math.floor(31.0)); //31.0
    System.out.println("=============");

    //
    System.out.println(Math.round(20.4)); // 20
    System.out.println(Math.round(10.5)); // 11
}

练习

题目：计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个。

分析：
1.既然确定了范围，用for循环
2.起点位置-10.8应该转换成为-10，两种办法：
    2.1 可以使用Math.ceil方法，向上（向正方向）取整
    2.2 强转成为int
3.每一个数字都是整数，所以步进表达式应该是num++, 这样每次都是+1的。
4.如何拿到绝对值，用Math.abs方法。
5.一旦发现了一个数字，需要计数器++进行统计。

如果使用Math.ceil方法，-10.8可以变成-10.0.注意double也是可以进行++的。

public static void main(String[] args) {
        int count = 0;

        double min = -10.8;
        double max = 5.9;
        // 这样处理，变量i就是区间之内所有的整数
//        for (int i = (int)min; i < 5.9; i++) {
        for(double i = Math.ceil(min);i < 5.9;i++){
//            int abs = Math.abs(i); //绝对值
            int abs = (int)Math.abs(i); //绝对值
            if (abs > 6 || abs < 2.1) {
                System.out.println(i);
                count++;
            }
        }

        System.out.println("总共有：" + count); // 9
    }

static关键字

概述

如果一个成员变量使用了static关键字，那么这个变量不再属于变量自己，而是属于所在的类。多个对象共享同一份。

// 静态static关键字修是成员变量作用就是用来做自动生成的数据。

使用

首先创建一个Student类

public class Student {

    private int id; // 学号
    private String name; //姓名
    private int age;     //年龄
    static String room;  //所在教室
    private static int idCounter = 0; //学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public static int getIdCounter() {
        return idCounter;
    }

    public static void setIdCounter(int idCounter) {
        Student.idCounter = idCounter;
    }

    public String getName() {return name;}

    public void setName(String name) { this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}
}

public static void main(String[] args) {

    // 首先设置一下教室，这是静态的定西，应该通过类名称进行调用。
    Student.room = "101教室";

    Student one = new Student("张三",19);
    System.out.println("one的姓名" + one.getName());
    System.out.println("one的年龄" + one.getAge());
    System.out.println("one的教室" + Student.room);
    System.out.println("=======================");

    Student two = new Student("李四",16);
    System.out.println("two的姓名" + two.getName());
    System.out.println("two的年龄" + two.getAge());
    System.out.println("two的教室" + Student.room);
}
结果：
    one的姓名张三
    one的年龄19
    one的教室101教室
    =======================
    two的姓名李四
    two的年龄16
    two的教室101教室

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用。如果有了static关键字，那么不需要创建对象，直接就能通过类名称使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行使用。静态变量：类名称.静态变量; 静态方法：类名称.静态方法();

注意事项： 1.静态只能直接访问静态，不能直接访问非静态。原因：因为在内存当中是【先】有的静态内容，【后】又的非静态内容。 “先人知道后人，后人不知道先人。” 2.静态方法当中不能用this。原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

首先创建一个myclass类

public class MyClass {

    int num; //成员变量
    static int numStatic; //静态变量

    //成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    //静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);

        // 静态方法不能直接访问非静态。 【重点】
//        System.out.println(num); //错误写法

        // 静态方法中不能使用this关键字。
//        System.out.println(this); //错误写法
    }

public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能使用没有static关键字的内容
        obj.method();

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); //正确，不推荐,这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic(); //正确，推荐

        // 对于本类当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod() {
        System.out.println("自己的方法！");
    }
}
结果：
    这是一个成员方法。
    0
    0
    这是一个静态方法。
    0
    这是一个静态方法。
    0
    自己的方法！
    自己的方法！

静态代码块

静态代码块的格式是：

public class 类名称{ static { // 静态代码块的内容 } }

静态代码块的特点是：当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：用来一次性的对静态成员变量进行赋值。

public class Person {
    static {
        System.out.println("静态代码块执行！");
    }
    public Person() {
        System.out.println("构造方法执行！");
    }
}

public static void main(String[] args) {
    Person one = new Person();
    Person two = new Person();
}
结果：
    静态代码块执行！
    构造方法执行！
    构造方法执行！

posted @ 2021-03-12 12:08 图图秃秃阅读(96) 评论(0) 收藏举报

刷新页面返回顶部