JAVA基础知识总结

关键字

关键字的特点：

1. 完全小写的字母
2. 在开发环境中有特殊颜色标记

标识符：

1. 是指在程序中，我们自己定义的内容，比如类的名字，方法的名字和变量的名字等，都是标识符

命名规则：

1. 标识符可以包含字母（区分大小写），0-9数字、美元符号和下划线_
2. 标识符不能以数字开头
3. 标识符不能是关键字

命名规范：

1. 类名规范:首字母大写，后面每个单词首字母大写（大驼峰式）
2. 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
3. 方法名字规范：同变量名

常量（不可发生改变的量）

常量的分类：

1. 字符串常量：凡使用双引号引起来的部分。例如“abc”
2. 整数常量：直接写上的数字，没有小数点。例如89,7,
3. 浮点型常量：直接写上的数字，有小数点。例如12.3
4. 字符常量：凡是用单引号引起来的单个字符。例如’S’（单引号之间必须有且只有一个字符）
5. 布尔常量：只有两种取值，true或者false
6. 空常量：null，代表没有任何数据 （空常量不能直接打印输出）

数据类型

1. 基本数据类型：整数、浮点数、字符、布尔
2. 引用数据类型：类、数组、接口

基本数据类型

数据类型	关键字	内存占用
字节型	byte	1个字节
短整型	short	2个字节
整形	int	4个字节
长整型	long	8个字节
单精度浮点数	float	4个字节
双精度浮点数	double	8个字节
字符型	char	2个字节
布尔类型	boolean	1个字节

注意事项：

1. 字符串是引用数据类型
2. 浮点型可能只是一个近似值，并不是精确的值
3. 数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节
4. 浮点数当中默认数据类型是double，如果一定要使用float类型，需要加上一个后缀F，如果是整数，默认是int类型，需要使用long类型，在后面加上L

变量（可以改变的量）

数据类型 变量名称 ；//创建一个变量

变量名称 = 数据值；//赋值

一步

数据类型 变量名称 = 数据值 ；

右侧数据值范围不能超过左侧数据类型的取值范围

注意：long 类型和float类型都要在结尾加上L或者F

数据类型转换

自动类型转换（隐式）：

1. 代码不需要特殊处理，自动完成
2. 数据范围从小到大
3. 数据范围从小到大是与字节数不相关的，byte<short<int<long<float<double

强制类型转换（显式）：

1. 数据范围大的数据转换为数据范围小的数据，需要强制类型转换，代码需要特殊的处理，不能自动完成
2. 格式：范围小的类型 范围小的变量名 =（范围小的类型）原本范围大的数据；
3. int num = (int) 100L;

**注意事项：**不推荐使用，可能会发生精度损失，数据溢出；

int num = (int) 600000000000L;//(数据超过int类型数据范围，发生数据溢出)

//double-->int
int num = (int) 3.5;//数据发生精度损失，这并不是四舍五入，所有的小数位置都会被舍弃掉
//输出的结果是3；

byte/short/char这三种类型都可以发生数学运算，例如加法"+"。（都会先提升为int类型，再进行运算）；

char zifu1 = 'A';
System.out.println(zifu1+1);
//输出的是66，计算机底层都是二进制的，字符A，就是65

ASCll码（字符）

0——48

A——65

a——97

以此类推

运算符

算数运算符：

1. 四则运算：加减乘除——+ - * / %（取模）
2. 除法公式：被除数/除数 = 商。。。余数
3. 对于整数表达式来说，除法是整除，结果仍然是整数，只看商，不看余数
4. 只有对于整数的除法来说，取模运算符才有意义，取模就是只看余数，不看商

注意事项：一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

四则运算符的三种用法：

1. 对于数据来说，就只是加法
2. 对于字符char来说，在计算之前，char会被提升为int类型，然后进行计算
3. 对于字符串String来说，加号代表字符串的连接（任何数据类型和字符串类型进行连接，都会变成字符串类型）
4. 小括号里面的优先执行

自增自减运算符

自增：++

自减：–

使用格式：写在变量名称之前，或者写在变量名称之后

使用方式：单独使用前++和后++没有任何区别

混合使用有重大区别：

1. 前++，先+1，再使用
2. 后++，先使用，后+1

自减运算符类似

注意：只有变量才能使用

赋值运算符

基本赋值："=" 代表将右侧的数据交给左侧的变量

复合赋值：

• += a+=1 相当于 a=a+1
• -= b-=4 相当于 b=b-4
• /= c/=5 相当于 c=c/5
• %= d%=6 相当于 d=d%6

注意：

1. 常量不能进行赋值
2. 复合赋值隐式的添加了强制类型转换

比较运算符（布尔类型）

==

!=

true/false

注意：

1. 进行多次判断时，不能进行连着写的
2. 成立就是true，不成立就是false

逻辑运算符

与	&&	全是true才是true，否则就是false
或	||	至少有一个是true就是true，双false就是false
非	!	true就变成false，反之

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

三元运算符

格式：数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；

流程：首先判断条件是否成立

1. 成立则为true，那么将表达式A赋值给变量
2. 不成立则为false，那么将表达式B赋值给变量

int max;
int a =100;
int b = 200;
max = a > b ? a ：b;

注意：三元运算符的结果必须得使用

必须同时保证表达式A和表达式B都符合左侧的数据类型的要求

方法入门

定义方法的格式

public static void 方法名称 （）{

​	//方法体

}

方法名称的命名规则和变量一样，使用小驼峰式

方法的调用：

1. 方法名称（）；

流程

判断语句

if(条件判断){
  语句体
}
//条件判断为true则执行语句体，反之；

if(条件判断){
 语句体1；
}else{
 语句体2；
}
//根据条件判断来选择执行哪条语句体；
if(int num % 2 ==0){
    //输出为偶数
}else{
    //输出为奇数
}

if(判断条件){
执行语句1；
}else if(判断条件){
执行语句2；
}else{
执行语句3；
}
//n者选其一
//例子

int x = 10;
int y ;
if(x>=3){
    y = 2*x+1;
}else if(-1<x&&x<3){
    y=2*X;
}else{
    语句体3；
}
//输出y

语句练习

package ifDome;

import com.sun.xml.internal.bind.v2.model.core.ID;

import java.util.Scanner;

public class Textif {
    /**
     *指定考试成绩，判断成绩等级
     * 90-100 优秀
     * 80-90  好
     * 70-79  良
     * 60-69  及格
     * 60以下 不及格
     */
    public static void main(String[] args) {
        System.out.println("请输入你的成绩：");
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();
       if (score<0||score>100){
           System.out.println("你的成绩是错误的");
       }else if(score >=90&&score<100){
           System.out.println("你的成绩是优秀");
       }else if(score>=80&&score<89){
           System.out.println("你的成绩是好");
       }else if(score>=70&&score<79){
           System.out.println("你的成绩是良好");
       }else if(score>=60&&score<69){
           System.out.println("你的成绩是及格");
       }else{
           System.out.println("你的成绩是不及格");
       }
    }
}

private static void maxDome() {
    //首先使用三元运算符
    int a = 30;
    int b = 20;
    int max = a > b ? a : b;
    System.out.println("最大值"+max);
    //使用今天的if语句
    if(a>b){
        max = a;
    }else {
        max = b;
    }
    System.out.println("最大值"+max);
}

选择语句——Switch

注意事项：

1. 多个case后面的数值不可以重复
2. switch后面的括号当中只能是下列数据类型：基本数据类型：byte/short/char/int 引用数据类型：string字符串、enum枚举
3. switch格式很灵活，前后顺序可以颠倒，break语句还可以省略

private static void switchDome() {
    switch (表达式){//表达式是被检测量
        case 常量值1:
            语句体1;
            break;
        case 常量值2:
            语句体2;
            break;
        case 常量值3:
            语句体3;
            break;
        case 常量值4:
            语句体4;
            break;
        default:
            语句体n+1;
            break;
    }
}

例子

private static void switchDome() {
    System.out.println("请输入数字:");
    Scanner sc = new Scanner(System.in);
    int num = sc.nextInt();
    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;
    }
}

循环语句----for

循环结构的基本组成部分，四部分

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

for(初始化表达式;布尔表达式;步进表达式){
    循环体;
}

while循环

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

while循环扩展格式：

初始化语句

while（条件判断）{

循环体；

步进表达式；

}

例子

private static void forDome() {
    int i =1;
    while (i<=100){
        System.out.println("你干哈"+i);
        i++;
    }
}

do_while循环

do {

循环体；

} while(条件判断)；

注意：while和后面加“；”

扩展 无条件执行第一次

初始化语句;
do{
    循环体;
    步进表达式;
    
}while (布尔表达式);

无脑执行第一次

do {
    System.out.println("走来"+i);
    i++;
}while (i<=10);

例子——1-100以内偶数的和

private static void sumDome() {
    int sum =0;
    for(int i =1;i<=100;i++){
        if(i%2==0){
            sum +=i;
        }
    }
    System.out.println(sum);
    
}

三种循环的区别

1. 如果条件判断从来没有满足过，那么for和while会执行0次，do_while会执行1次；
2. for循环的变量在小括号中定义，只有在内部循环中才可以使用，while循环和do_while循环初始化语句本来就在外面，循环结束还可以继续使用；

break

可以用在switch语句中，一旦执行，整个switch语句立即结束

还可以用在循环语句中，一旦执行，整个循环语句立即结束，打断循环

循环的选择：

凡是次数确定的场景多用for循环，狗则多用while循环

continue

另一种是循环语句中的continue关键字

一旦执行，立即跳过当前次循环剩余内容，马上开始下一次的循环

private static void dome() {
    for (int i = 1; i <= 10; i++) {
        if(i==4){
            continue;
        }
        System.out.println(i+"层到了");
    }
}

死循环

永远停不下来的循环

循环的嵌套用法

private static void timeDome() {
    for (int i = 0; i < 24; i++) {
        //外层控制小时
        for (int j = 0; j < 60; j++) {
            //内层控制小时之内的分钟
            System.out.println(i + "点" + j + "分");

        }

    }
}

IDEA项目结构

项目project

模块 model

包 package

package day04;

public class Dome01 {
    /*定义方法
    * public static void 方法名称（）{
    *   方法体;
    * }
    * 
    * 调用格式：
    * 方法名称（）;
    * */
    
    /**
     * 方法调用的注意事项：
     * 方法定义的先后顺序无所谓
     * 方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法
     * 方法定义后，自己不会主动执行，一定要方法的调用*/
    
    public static void main(String[] args) {
        forDome();
    }
    public static void forDome(){
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 20; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

方法的调用

package day04;
/*方法就是若干语句的集合
 *
 * 方法就好像一个工厂
 *
 * 原料：
 * 产出物：
 * 参数（原料），就是进入方法的数据
 * 返回值（产出物），就是从方法中出来的数据
 *
 * 定义方法的基本格式：
 * 修饰符 返回值类型 方法名称（参数类型 参数名称....）{
 *  方法体
 *   return 返回值；
 * }
 *
 * 修饰符：现阶段的固定写法，public static
 *
 * 返回值类型：也就是方法最终产生的数据结果是什么类型
 * 方法名称：方法的名字，规则和变量一样，小驼峰
 * 参数类型：进入方法的数据类型
 * 参数名称：就是进入方法的变量
 *
 * 参数如果有多个 需要用逗号分隔
 * return：停止当前的方法，将后面的结构数据返回给调用处
 * 返回值：方法执行后产生的数据结果
 *
 * 注意：return的返回值类型，必须与方法名称前面的返回值类型，保持对应
 *
 * 方法的三种调用格式：
 * 单独调用：方法名称（参数）;
 * 打印调用
 * 赋值调用
 * 
 * 注意：此前学习的方法 返回值类型为void，这种方法只能通过单独调用
 * */

public class Dome02 {
    public static void main(String[] args) {
        //单独调用
        sum(10,20);
        System.out.println("=====================");
        //打印调用
        System.out.println(sum(10,20));
        System.out.println("=====================");
        //赋值调用
        int num = sum(10,80);
        System.out.println("变量的值"+num);
    }

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

}

有参无参的区别

package day04;
/*
* 有参数：小括号中有内容，一个方法需要一些数据条件才能完成任务
* 无参数：不需要任何数据就能完成，自己可以独立完成
* */
public class Dome03 {
    public static void main(String[] args) {
        method01(10,60);
        method02();
    }
    //俩个数字相乘，必须知道两个数据都是多少，否则无法计算
    public static void method01(int a,int b){
        int result =a*b;
        System.out.println("结果是"+result);
    }
    //打印十次字符串
    public static void method02(){
        for (int i = 0; i < 10; i++) {
            System.out.println("你好啊");
        }
    }
}

对比有返回值和没有返回值

public class Back {
    /*题目要求：定义一个方法，用来求出两个数字之和，计算完成之后将返回值结果告诉我
     * 题目变形：定义一个方法，用来打印两个数字之和，自己计算 直接打印*/

    public static void main(String[] args) {
        int sum = getSum(10, 20);
        System.out.println(sum);
    }

    //我是一个方法，负责计算两个数字相加，我有返回值，谁调用我 我就将结果告诉谁
    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);
    }
}

注意事项：

1. 对于有返回值的方法，可以使用单独调用，打印调用和赋值调用
2. 对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用

使用方法的注意事项：

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

方法的重载（overload）

功能类似的方法，参数相似，就可以用方法的重载

方法的名称相同，参数列表不同

好处：只需要记住一个方法名称，就可以实现多个类似的功能

方法重载与下列因素相关：

1. 参数个数不同
2. 参数类型不同
3. 参数多类型顺序不同

参数重载与下列因素无关：

1. 参数名称无关
2. 与方法的返回值类型无关

数组的概念

数组的特点：

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

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

两种常见的初始化方式：

1. 动态初始化（指定长度）
2. 静态初始化（指定内容）

动态初始化格式：

数据类型[] 数组名称 = new 数据类型[数组长度]；

静态初始化省略格式：

数据类型[] 数组名称 = {元素1, 元素2,元素3…};

注意事项：

1. 静态初始化可以拆分为两个步骤
2. 静态初始化没有指定数组长度，但是仍然会自动推算得到的长度
3. 动态初始化也可以拆分为两个步骤
4. 静态初始化省略格式就不可以拆分为两个步骤

int[] arrayA = new int[3];//动态数组
int[] arrayB ={1,2,3,4};//静态数组

访问数组元素的格式：

1. 数组名称[索引值]
2. 索引值 就是一个int类型，代表数组当中的元素编号
3. 注意：索引值是从0开始的，一直到 数组的长度-1 为止

初始化数组的时候，其中的元素会自动拥有一个默认值，规则如下：

1. 整数类型 0
2. 浮点类型 0.0
3. 字符类型 ‘\u0000’
4. 布尔类型 false
5. 引用类型 null

//将123赋值给array中的一号元素
array[1] = 123;

数组索引越界异常

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

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

常见问题

空指针异常NullPointerException

数组没有初始化，数组可以初始化为null，因为数组是引用类型

如果只赋值了null，没有进行new创建，那么会发生空指针异常

如何获取数组的长度

静态初始化获取数组长度——数组.length

int len = arrayA.length;//数组一旦创建，运行期间，数组长度不可改变

数组打印输出的API

String[] array = {"贾乃亮","陈羽凡","王宝强"};
        //打印数组内容的Api是Arrays.toString(array)
        System.out.println(Arrays.toString(array));
        //遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

数组的遍历输出：就是对数组的每一个元素进行打印输出

/*数组的遍历输出*/
public static void main(String[] args) {
    int[] arrayA = {1, 2, 3, 4, 55, 66, 77};
    //使用循环
    for (int i = 0; i < arrayA.length; i++) {
        System.out.println(arrayA[i]);
    }
}

例子：求出最值

/*求出最值*/
public class Dome02 {
    public static void main(String[] args) {
        int[] array ={10,5,15,20,30,60};

        int max =array[0];
        for (int i = 0; i < array.length; i++) {
            //如果当前元素比max更大，那就换人
            if(array[i]>max){
                max = array[i];
            }
        }
        System.out.println("最大值是："+max);
    }
}

数组元素反转

package dome01;
/*数组元素的反转
 * 本来的样子{1,2,3,4}
 * 反转之后{4,3,2,1}*/


//要求：不能使用新数组

//数序元素的反转 就是对称元素的交换
public class Dome03 {
    public static void main(String[] args) {
        //最简单的数组元素反转
        int[] array = {1, 22, 33, 44, 55};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=======================");
        /*初始化语句：int min = 0,int max = array.length-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]);
        }
    }
}

数组作为方法的参数

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

如果希望一个方法的返回值当中产生多个结果数据进行返回，怎么办？

解决方案：使用一个数组作为返回值类型即可。

package dome01;

public class Dome04 {
    public static void main(String[] args) {
        int[] result =calculate(1,2,3);
        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;
        int[] array = {sum,avg};
        return array;
    }
}

面向对象

当需要的实现一个功能时，不关心具体步骤，而是找到一个已经拥有该功能的人，来帮助我做事

package ifDome;


import java.util.Arrays;

public class Dome01 {
    public static void main(String[] args) {
        int[] array = {1,3,5,66,545,88,44};
        /*要求打印格式为：[1,3,5,66,545,88,44]*/

        //使用面向过程的方法
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                System.out.print(array[i]+"]");
            }else{
                System.out.print(array[i]+",");
            }

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

        //使用面向对象的方法
        System.out.println(Arrays.toString(array));
    }
}

• 使用面向对象
• 找一个JDK给我们提供好的Array类
• 其中有一个toString 方法，直接就能把数组变成想要的格式的字符串

面向对象的三大特征：

封装、继承、多态

package ifDome;
/*
* 定义一个类，就是模拟学生事物，其中有两个组成部分
* 
* 属性：是什么
* 姓名
* 年龄
* 行为：能做什么
* 吃饭
* 睡觉
* 学习
* 
* 
* 成员变量：姓名 年龄
* 成员方法：吃饭 睡觉 学习*/

/*
* 注意事项：
* 成员变量是直接定义在类当中的，在方法的外边
* 成员方法不要写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("学习");
    }
}

创建对象 使用成员变量 和成员方法

package ifDome;

/*通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用
 *
 * 创建格式：
 * 类名称 对象名称 = new 类名称（）；
 *
 * 使用：分两种情况
 * 使用成员变量：对象名称.成员变量名
 * 使用成员方法：对象名称.成员方法名（）_想用谁就对象名.谁
 * */

public class Dome02Student {
    public static void main(String[] args) {
        Student student = new Student();
        //使用成员方法
        student.eat();
        student.sleep();
        student.study();
        //使用成员变量
        //将右面的字符串赋值给左边的成员变量
        student.name = "赵丽颖";
        student.age = 18;
        System.out.println(student.age);
        System.out.println(student.name);
    }
}

注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样

​ 改变对像当中的成员变量内容

内存中分为五块区域:

1. 栈stack
2. 堆heap
3. 方法区method area

使用对象类型作为方法的参数

public class Dome02PhoneParam {
    public static void main(String[] args) {
        Phone one = new Phone();
        one.name ="苹果";
        one.color ="红色";
        one.price =15.5;
        //调用方法
        method(one);
    }
    public static void method(Phone co){
        System.out.println(co.name);
        System.out.println(co.color);
        System.out.println(co.price);
    }
}

注意事项：当一个对象作为参数，传递到方法中去，实际上传递进去的是对象的地址值

使用对象类型作为方法的返回值类型

public class Dome02PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.name);
        System.out.println(two.price);
        System.out.println(two.color);
    }
    //返回值类型是对象类型
    public static Phone getPhone(){
        Phone one = new Phone();
        one.price = 15.2;
        one.color ="玫瑰金";
        one.name ="苹果";
        return one;
    }
}

成员变量和局部变量的区别

/*局部变量和成员变量
 * 1.定义的位置不一样（重点）
 * 成员变量：方法的外部，直接写在类当中
 * 局部变量：在方法的内部
 *
 * 2.作用域不一样
 * 局部变量：只有在方法内使用，出了方法就失效
 * 成员变量：在整个类中都可以使用
 *
 * 3.默认值不一样（重点）
 * 局部变量：没有默认值，想使用，先赋值
 * 成员变量：有默认值
 *
 * 4.内存的位置不一样（了解）
 * 局部变量：位于栈内存
 * 成员变量：位于堆内存
 *
 * 5.生命周期不一样（了解）
 * 局部变量：随着方法进栈而诞生，随着方法出栈而消失
 * 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失*/

注意事项：

1. 局部变量想要使用，必须先赋值
2. 方法的参数就是局部变量
3. 参数在方法的调用时，必然会被赋值的

封装性

1. 方法就是一种封装
2. 关键字private也是一种封装

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

一旦使用private进行修饰，本类当中还是可以随意访问，但是，超出部分就无法直接访问了。

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

必须叫setXxx或者getXxx命名规则

对于getter来说，不能有参数，返回值类型和成员变量类型对应

对于setter来说，不能有返回值，参数类型和成员变量类型对应

  public int getAge() {
        return age;
    }

//这个成员方法专用于向age设置数据
    public void setAge(int age) {
        //在这里边进行条件的判断
        this.age = age;
    }

this关键字的作用

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

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

构造方法

是用来创建对象的方法，当我们通过关键字new来创建对象的时候，其实就是在调用构造方法

格式：public 类名称（参数类型 参数名称）{

方法体

}

注意事项：

1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样；

2. 构造方法不要写返回值类型，连void都不要写

3. 构造方法不能return一个具体的返回值

4. 如果没有编写任何构造方法，那么编译器赠送一个构造方法，没有参数，方法提什么事情也不做

5. 一旦编写了至少一个，编译器不再赠送

6. 构造方法也是可以进行重载的

   重载：方法名称相同，参数列表不同

   java Bean

   /*一个标准的类通常要拥有以下四个组成部分
    *
    * 1.所有的成员变量都要使用private关键字修饰
    * 2.为每一个成员变量编写一对getter/setter方法
    * 3.编写一个无参数构造方法
    * 4.编写一个全参数构造方法
    * 
    * 这样的标准的类也叫做 java Bean*/
   public class Student {
       private String name;//姓名
       private int age;//年龄
   
       public Student(String name, int age) {
           this.name = name;
           this.age = age;
       }
   
       public Student() {
       }
   
       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;
       }
   }
   

常用的API

Scanner类

package dome04;

import java.util.Scanner;

/*Scanner类，可以实现键盘录入数据，到程序当中
 *
 * 引用类型的一般使用步骤
 *
 * 只用java.lang包下的内容不需要导包，其他的包都需要import语句
 * */
public class Dome04Scanner {

    public static void main(String[] args) {
        System.out.println("请输入数字：");
        //备注：System.in就是从键盘输入
        Scanner sc = new Scanner(System.in);
        //获取键盘输入的字符串string s = sc.next();
        int num = sc.nextInt();
        System.out.println("输入的键盘数字是" + num);

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

练习题目：键盘输入两个int类型数字计算相应的和；

import java.util.Scanner;

/*题目：键盘输入两个int数字，求和
 *思路：*/
public class Dome04SUm {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字a:");
        int a = sc.nextInt();
        System.out.println("请输入数字b:");
        int b = sc.nextInt();
        int result = a + b;
        System.out.println("结果是"+result);


    }
}

package dome04;

import java.util.Scanner;

/*键盘输入三个数字，求出其中的最大值*/
public class Dome04Max {
    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);
    }
}

匿名对象 eg: new Person(); 就是直接new出来的

注意事项：只能使用一次，下次再用不得不创建一个新对象

使用建议：如果确定一个对象只使用一次，就可以用匿名对象

匿名对象作为参数的返回值和参数

package dome04;

import java.util.Scanner;

public class Dome {
    public static void main(String[] args) {
        /*//普通方式
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字：");
        int s = sc.nextInt();
        System.out.println("输入的数字是"+s);

        //匿名对象方式
        int a =  new Scanner(System.in).nextInt();
        System.out.println("输入的数字是"+a);
        */

        //使用匿名对象进行传参
        getMethod(new Scanner(System.in));
    }
    public static void getMethod(Scanner sc){
        int sun = sc.nextInt();
        System.out.println("输出的是"+sun);
    }
}

Random类

package dome04;
/*使用：
* 获取一个随机的int数字（范围是int的所有范围，有正负两种）
* 获取一个随机的int数字（参数代表了范围，左闭右开区间）
* int nun = r.nextInt(3);
* 实际含义就是0-2*/
import java.util.Random;
import java.util.function.DoubleToIntFunction;

public class Dome04Random {
    public static void main(String[] args) {
       int n =5;
       Random r = new Random();
        //本来的范围是【0，n),整体+1之后就是【1，n】
        int result = r.nextInt(n) + 1;
        System.out.println(result);
    }
}

猜数字小游戏

package dome04;

import java.util.Random;
import java.util.Scanner;

/*猜字小游戏
* */
public class Dome04Guss {
    public static void main(String[] args) {
        Random r = new Random();
        int resultNum = r.nextInt(100)+1;

        Scanner sc =  new Scanner(System.in);


        while (true){
            System.out.println("请输入你猜测的数字");
            int gussNum = sc.nextInt();
            
            if(gussNum>resultNum){
                System.out.println("太大了，请重试");

            }else if(gussNum<resultNum){
                System.out.println("太小了，请重试");
            }else {
                System.out.println("恭喜你，猜对了");
                break;
            }
        }

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-awy2h0Pf-1600214604321)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911074708713.png)]

对象数组

任何数据类型都可以作为数组的类型

**缺点：**一旦创建，程序运行期间长度不可改变

数组的长度是不可以改变的，但是ArrayList长度是可以改变的

ArrayList 泛型

ArrayList的常用API

package dome04;

import java.util.ArrayList;
import java.util.List;
/*对于ArrayList集合来说，add添加动作一定是成功的*/
public class Dome04ArrayLit {
    public static void main(String[] args) {

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

        //向集合中添加元素
        arrayList.add("赵丽颖");
        arrayList.add("赵又廷");
        System.out.println(arrayList);//[赵丽颖, 赵又廷]

        //从集合中获取元素：get.索引值从0开始
        String name = arrayList.get(0);
        System.out.println("第一号索引位置"+name);//第一号索引位置赵丽颖

        //从集合中删除元素remove
        String whoRemove = arrayList.remove(0);
        System.out.println(arrayList);//[赵又廷]

        int size =arrayList.size();
        System.out.println("集合的长度是"+size);//集合的长度是1
    }
}

遍历集合ArrayList

package dome04;

import java.util.ArrayList;
import java.util.Arrays;

//遍历ArrayList集合
public class Dome04For {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("李小璐");
        list.add("白百合");
        list.add("马蓉");
        System.out.println(list);

        String[] array = {"贾乃亮","陈羽凡","王宝强"};
        //打印数组内容的Api是Arrays.toString(array)
        System.out.println(Arrays.toString(array));
        //遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ShHRgs7U-1600214604330)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911092919085.png)]

泛型只能是引用数据类型

基本类型	包装类
byte	Byte
short	A
int	Integer【特殊】
long	Long
float	Float
double	Double
char	Character【特殊】
boolean	V

package dome04;

import java.util.ArrayList;
import java.util.Arrays;

/*泛型只能是引用数据类型
*
* 向ArrayList集合中存储基本数据类型就必须使用相应“包装类”
* */
public class Dome04Basic {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(9);
        list.add(222);
        System.out.println(list);

        System.out.println(list.get(2));
    }
}

题目：生成1-33之间的6个随机数字，将他们加入到集合中去，进而遍历集合

package dome04;

import java.util.ArrayList;
import java.util.Random;

/*题目：生成6个1——33之间的随机整数，添加到集合，并遍历集合
* 思路：
* 需要循环6次产生6个随机数字，for循环
* 随机数字是random，1-33是有参数的获得
* 循环的每一次将得到的随机数字加入到集合中去
* 最后遍历集合*/
public class Dome01 {
    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);
        }
        System.out.println(list);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

}

运行效果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nwNskHlf-1600214604332)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911094759629.png)]

自定义类型充当泛型

package dome04;

public class People {
    private String name;
    private int age;

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

    public People() {
    }

    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;
    }

    @Override
    public String toString() {
        return name+age;
    }
}

package dome04;

import java.util.ArrayList;

public class Dome02 {
    public static void main(String[] args) {
        ArrayList<People> list = new ArrayList<>();
        list.add(new People("江富道",23));
        list.add(new People("孙诗博",24));
        list.add(new People("李斯文",23));
        list.add(new People("刘勇许",22));
        System.out.println(list);

        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName()+list.get(i).getAge());
        }
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sIIRpuEv-1600214604336)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911095901536.png)]

指定格式遍历集合字符串

package dome04;

import java.util.ArrayList;
/*将ArrayList集合按照自定义格式打印出来*/
public class Dome03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张翠山");
        list.add("张无忌");
        list.add("张丹峰");
        list.add("张留生");
        //默认样式
        System.out.println(list);

        //自定义样式
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            if(i==list.size()-1){
                System.out.print(list.get(i)+"}");
            }else{
                System.out.print(list.get(i)+"@");
            }
        }
        


    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sURT2bYy-1600214604339)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911113607456.png)]

题目：用一个大集合存储20个随机数字，然后筛选其中的偶数元素，放到小集合当中。

​ 要求使用自定义的方法来实现筛选

package dome04;

import javax.swing.text.StyleContext;
import java.util.ArrayList;
import java.util.Random;

/*用一个大的集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中去
 * 要求自定义方法来实现筛选*/
public class Dome04 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;
            list.add(num);
        }
        System.out.println(list);

        ArrayList<Integer> smallList = getSmallList(list);
        System.out.println(smallList);
        //遍历小集合的元素
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));
        }

    }

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

字符串的概述和特点

package dome05;
/*程序中所有的双引号的面值都是字符串
* 字符串一旦创建不能改变
* 字符串的底层就是用的byte字节数组
*
* 创建字符串的三种方法
* public String()创建一个空白字符串，不含任何内容
* public String(char[] array)根据字符数组的内容，来创建相应的字符串
* public String(byte[] array)根据字节数组的内容，来创建相应的字符串
*
* 一种直接创建：
* 注意：直接写上双引号，就是字符串的对象
*
* */
public class Dome01 {
    public static void main(String[] args) {

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

        //根据字符数组创建
        char[] array = {'A','B','C'};
        String str2 = new String(array);
        System.out.println("第二个字符串是"+str2);

        //根据字节数组创建
        byte[] bytearray = {97,98,99};
        String str3 = new String(bytearray);
        System.out.println("第三个字符串的内容是"+str3);

        //直接创建
        String str4 = "你是谁";
    }
}

运行结果是

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yi9FndVB-1600214604341)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911151852996.png)]

字符串从常量池

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

字符串常量池在堆当中

字符串常用方法

任何对象都能用object接收

public boolean equals(Object obj)

package dome05;

import com.sun.xml.internal.ws.message.stream.StreamHeader12;

/**/
public class Dome03 {
    public static void main(String[] args) {
        //获取字符串的长度
        int length = "aaifiefjawhfiowejfa".length();
        System.out.println("字符串的长度是"+length);

        //拼接字符串
        String str1 ="Hello";
        String str2  ="World";
        String str3 =str1.concat(str2);
        System.out.println(str1);//原封不动
        System.out.println(str2);//原封不动
        System.out.println(str3);//拼接的新字符串

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

        //查找参数字符串在本来字符串当中出现的第一次索引位置
        
        String a = "HelloWorld";
        int index = a.indexOf("llo");
        System.out.println("第一次索引值是"+index);
        //如果根本没有 返回-1值
        System.out.println("hhh".indexOf("abc"));


    }
}

字符串的截取方法

package dome05;

import org.omg.CORBA.ARG_OUT;

//字符串的截取,包含左边不包含右边
public class Dome04 {
    public static void main(String[] args) {
        String str = "HelloWorld";
        String str1 = str.substring(5);
        System.out.println(str1);//新字符串


        String str2 = str.substring(4,7);
        System.out.println(str2);

        //只是地址值改变了，但是字符串常量是不可改变的
        String a = "hello";
        System.out.println(a);
        a="world";
        System.out.println(a);


    }
}

String字符串相关转换方法

package dome05;


/*String当中与转换相关的方法有
*
* public char[] toCharArray(),将当前字符串拆分成为字符数组作为返回值
*
* public byte[] getBytes(),获取字符串底层的字节数组作为返回值
* 
* 字符串的内容的替换repalce("字符","新字符")*/
public class Dome05 {

    public static void main(String[] args) {
        //将字符串转换成字符数组
        char[] chars ="Hello".toCharArray();
        //遍历字符数组
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

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

        //将字符串转换成字节数组
        byte[] bytes = "abc".getBytes();
        //遍历字节数组
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("===================");

        //替换原来的字符串的字符进而输出新的字符串
        String result = "How do you do?";
        String dome = result.replace("o", "*");
        System.out.println(result);//原来的字符串
        System.out.println(dome);//新的字符串


    }
}

分隔字符串

package dome05;

/*分割字符串的方法：
 * public String[] split(String[] args)
 *
 * 注意事项：split方法的参数是一个正则表达式
 * 如果按照英文句点进行分隔进行分隔需要加\\.*/
public class Dome06 {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        //以“，”为标志进行分隔
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }

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

        String a = "xxx.yyy.zzz";
        String[] array = a.split("\\.");
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

按指定格式拼接字符串

package dome05;

/*按指定格式拼接字符串
 *
 * 题目：定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下：【Word1#word2#Word3】*/
public class Dome07 {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        System.out.println(fromStringToArray(array1));
    }

    public static String fromStringToArray(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;
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q7yeoAew-1600214604345)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912081550512.png)]

题目：键盘输入字符串统计各种字符出现的次数

package dome05;

import java.util.Scanner;

/*题目：键盘输入一个字符串，统计其中各种字符出现的次数
* 种类有：大写字母、小写字母、数字、其他
*
* 思路：
* 键盘输入Scanner
* 字符串sc.next()
* 定义四个变量分别代表四种字符出现的次数
* 对字符串进行检查，方法是toCharArray()
* 遍历char[]字符数组，对当前字符的种类进行判断，且用四个变量进行++动作
* 打印四个变量 显示各种字符出现的次数
* */
public class Dome08 {
    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[] chars = input.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch =chars[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);
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hrjU7QRU-1600214604346)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912083155230.png)]

Static关键字使用

静态static关键字修饰成员变量

package dome05;

public class Student {
    private String name;
    private int age;
    private static int countId = 0;//让id在每一次创建对象的时候都顺序递增
    private int id;
    static String room;//static修饰的静态成员变量，是属于类本身的

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++countId;//递增
    }

    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 int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Student() {
        this.id = ++countId;//递增
    }
}

测试类

package dome05;
/*
* 如果一个成员变量使用了static关键字，那么这个成员变量就属于类*/
public class Dome09 {
    public static void main(String[] args) {
        Student a = new Student("江富道",18);
        a.room="过控1703";
        System.out.println("姓名是"+a.getName()+"，年龄是"
                +a.getAge()+"，班级是"+a.room+"，id是"+a.getId());

        Student b = new Student("牛结实",22);
        System.out.println("姓名是"+b.getName()+"，年龄是"
                +b.getAge()+"，班级是"+b.room+"，id是"+b.getId());
    }
}

运行结果是

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gWcKGR1Y-1600214604348)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912091454332.png)]

静态关键字修饰成员方法，就是静态方法，属于类

如果没有static关键字就是实例方法，需要创建对象，才能使用它

无论是成员变量还是成员方法都推荐使用类名称.成员变量/成员方法来调用

注意事项：

• 在本类当中调用静态，可以省略类名称
• 静态不能访问非静态（静态方法不可以访问非静态内容）
• 静态方法当中不能使用this，this代表哪个对象调用的

注意：根据类名称访问静态成员变量，跟对象没任何关系

静态代码块

格式：
$$
public class 类名称{

static{

   语句体；

}

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

静态内容总是优先于非静态的，静态代码块优先于构造方法

典型用途：

用来一次性的对静态成员变量进行赋值

数组工具类Arrays

说明：数组工具类的常用方法

package dome05;

/*数组工具类Arrays
*
* 将数组转成字符串类型（默认）Arrays.toString(数组名称)
*
* 将数组按照默认升序的方式进行排序，是void 类型，无返回值，Arrays.sort(数组名称)*/
import java.util.Arrays;

public class Dome010 {
    public static void main(String[] args) {
        int[] array = {10,20,30};
        //将int[]数组按照默认格式转成字符串
        String str = Arrays.toString(array);
        System.out.println(str);
        System.out.println("=========");

        //按照默认升序对数组元素进行排序
        int[] array1 ={48,15,236,88,44,255,11,1};
        //排序，void类型，没有返回值
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));

        System.out.println("=================");
        //如果是字符串类型的数组，按照字母升序排列
        //如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持
        String[] array3 = {"bbb","ccc","aaa"};
        Arrays.sort(array3);
        System.out.println(Arrays.toString(array3));
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vHYgZlQ5-1600214604350)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912100643898.png)]

练习题目：

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

package dome07;

import java.util.Arrays;
import java.util.Scanner;

/*键盘输入一个字符串，将字符串中的字符按升序排列，然后倒序打印*/
public class Dome01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个随机字符串：");
        String str = sc.next();
        //将字符串转换成字符数组
        char[] charArray = str.toCharArray();
        Arrays.sort(charArray);
        System.out.println(charArray);//升序排列的数组

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

        //倒序打印
        for (int i = charArray.length - 1; i >= 0; i--) {
            System.out.println(charArray[i]);
        }
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PnaIyNNp-1600214604352)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912101841827.png)]

数学工具类Math

package dome07;
/*public static boolean abs(double num),获取绝对值
* public static boolean ceil(double num),向上取整
* public static boolean floor(double num),向下取整
* public static boolean round(double num).四舍五入
*
* */
public class Dome02 {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(-1));
        System.out.println(Math.abs(0));

        //向上取整
        System.out.println(Math.ceil(3.4));

        //向下取整
        System.out.println(Math.floor(3.9));

        //四舍五入
        System.out.println(Math.round(3.5));
    }
}

运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YZfIY66O-1600214604354)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912104416313.png)]

练习题

package dome07;
/*计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个*/
public class Dome03 {
    public static void main(String[] args) {
        int count =0;//符合要求的数量

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HQnFilak-1600214604356)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912111028113.png)]

继承

继承主要解决的问题就是：共性抽取

当子类、父类、局部变量都是相同的名称时

局部变量	直接写
本类的成员变量	this.成员变量名称
父类的成员变量	super.成员变量名称

继承中成员方法的访问特点

在父子类中，父子类方法重名时，方法的调用原则

规则：创建的对象是谁就优先调用谁的方法，没有就往上找，就近原则

在继承关系中，方法的名称一样，参数列表也一样

重写/覆盖/覆写	在继承关系中，方法名称和参数一样
重载	方法的名称一样，方法的参数列表不一样

注意事项：方法的重写

1. 子类方法的返回值范围一定要小于父类的返回值范围
2. 子类方法的权限必须大于父类方法的权限修饰符public>projected>(default)>private

备注：default不是关键字，是省略不写