JAVA基础知识总结

笔记 专栏收录该内容
25 篇文章 0 订阅

关键字

关键字的特点:

  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. 引用数据类型:类、数组、接口

基本数据类型

数据类型关键字内存占用
字节型byte1个字节
短整型short2个字节
整形int4个字节
长整型long8个字节
单精度浮点数float4个字节
双精度浮点数double8个字节
字符型char2个字节
布尔类型boolean1个字节

注意事项:

  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)]

泛型只能是引用数据类型

基本类型包装类
byteByte
shortA
intInteger【特殊】
longLong
floatFloat
doubleDouble
charCharacter【特殊】
booleanV
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不是关键字,是省略不写

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值