精华内容
下载资源
问答
  • 输入(Scanner类)Scanner 是 Java5 的新特征,在java.util包里,可以完成用户输入,使用如下:1. 导入java.util包;2. 构造Scanner对象,参数为标准输入流http://System.in;3. 使用next()方法系列接收数据;常用...

    6461bfb5cc60f5b7c61397cd1bae7470.png

    输入和输出是计算机最基本的功能,Java也提供了多种方式完成输入输出,本篇主要分享最基础,最常用的。

    输入(Scanner类)

    Scanner 是 Java5 的新特征,在java.util包里,可以完成用户输入,使用如下:

    1. 导入java.util包;

    2. 构造Scanner对象,参数为标准输入流http://System.in;

    3. 使用next()方法系列接收数据;常用方法如下:

    • String nextLine()

    接收输入的一行内容(以回车作为分隔符)

    • String next()

    接收输入的一个单词(以空格作为分隔符)

    • int nextInt()
    • double nextDouble()

    接收输入的一个整数或浮点数

    • boolean hasNext()

    检测是否还有单词输入

    • boolean hasNextInt()
    • boolean hasNextDouble()

    检测输入中是否整数或浮点数

    //来源【时光与字节】
    

    运行结果

    输入数据:This is Java code
    接收的单词s1:This
    接收的一行字符串s2:is Java code
    输入整数:23
    整数数据i:23
    输入小数:12.36
    小数数据f:12.36

    几点说明:

    1. next()不接收带空格的字符串,输入字符串前面的空格next()会去掉,后面的空格作为分隔符或者结束符。

    2. 当输入多个数据时,第一个next()接收到数据,下一个next()发现字节流里面有东西,就不会阻塞等待输入了,会直接接收。

    • 如上例中,输入“This is Java code” ,s1用next()只接受一个单词“This”,s2用nextLine()接收了剩余的部分。

    3. 要输入 int 或 float /double类型的数据,最好先使用 hasNextXxx() 方法进行验证

    4. Scanner对象用完最后用close()关闭掉,不然会告警。

    输出(print,println,printf)

    System.out.print():是最常用的输出语句,它会把括号里的内容转换成字符串输出到输出窗口(控制台)。

    System.out.println():与print()基本一样,区别就是输出完成后执行换行。

    System.out.printf():这个方法延续了C语言的输出方式,通过格式化文本和参数列表输出。

    重点说一下printf(),这个方法能按照我们的需求进行格式化的输出,如输出要控制小数的位数、数字前补0、输出对齐、加分隔符等等。

    基本格式:两个参数,第一个是格式控制符,第二个可变长,表示待输出数据对象。

    System.out.printf(“格式控制”,表达式1,表达式2,……,表达式n)

    每个格式控制以%开始,后跟被格式化的数值类型,如:%d表示int型。输出时每个格式控制都用后面相应位置的表达式值替换。

    两个部分说明:

    1. 常用的格式控制符(字符数值类):

    b1f10c77bb469898b2a8fd879bdf046d.png
    //来源【时光与字节】
    

    运行结果

    字符串:时光与字节;
    数字:18;
    小数(默认六位):98.675000
    整数留五列不足前面添零:00018
    小数点后留两位:98.68
    整数八进制输出:22
    小数共6列,小数点后1位:0098.7
    前加正号、千位分隔符:+36,521.25

    2. 时间日期类格式化输出

    %t表示格式化日期时间类型,%T是时间日期的大写形式,在%t之后用特定的字母表示不同的输出格式 。下表只列出常用的日期类控制符。

    2027f06e5f7b9803c578393ec0bdf58e.png
    //来源【时光与字节】
    

    运行结果

    2019-10-07
    21:47:38
    09:47:38 下午
    2019
    19
    10
    07
    星期一
    今天是:19年10月07日,J_ZHANG

    注:格式化输出的相关控制符有很多,上面只是部分常用的,详细的可参看JDK文档:

    java.util.Formatter

    ~~~~~~~~~~~~

    如果觉得有一点帮助,帮忙点个赞,支持一下。

    推荐一下我的公众号:【时光与字节】,更多原创分享。

    谢谢你的支持!

    1ce973d4b8fcf46fea11d06eabc1f04c.png
    展开全文
  • 、初识Java编程1Java开发环境 JDK Java开发工具JVM Java虚拟机JRE Java运行环境2、实现第个hello worldpublic class Hello{ public static void main(String[] args){ System.out.println("hello man!...

    一、初识Java编程

    1、Java开发环境

    JDK Java开发工具

    JVM Java虚拟机

    JRE Java运行环境

    719fa05e974cedbb06333193248337e9.png

    2、实现第一个hello world

    public class Hello{

    public static void main(String[] args){

    System.out.println("hello man!");

    }

    }

    执行代码:

    (1) 在命令窗体输入: javac 文件名.java

    (2) 输入:java 文件名

    注意:

    (1) 类名和文件名要保持一致;

    (2) Java源代码中的所有标点符号使用英文输入法状态输入;

    (3) Java源代码是区分大小写;

    (4) 类名默认都使用大写;

    3、Java运行原理

    40f9cf2ea50e1bfb8d939e9413f18a82.png

    4、变量的声明

    声明语法:

    数据类型 变量名 ;

    赋值:

    变量名 = 值;

    示例:

    public class Hello{

    public static void main(String[] args){

    //声明整数类型的a,在内存中创建这个变量

    int a;

    double b;

    double c;

    //给变量赋值

    a = 1;

    b = 2;

    System.out.println(a/b);

    }

    }

    5、标识符

    (1) 标识符是用于类名、变量名、方法名、对象名、数组名等的命名;

    (2) 可以使用英文、数字、下划线_、$符号;

    (3) 不能以数字开头;

    (4) 不能使用Java关键字或保留字;

    (5) 区分大小写;

    6、注意事项

    (1)当声明的类使用public关键字修饰时,源文件名必须和类名保持一致;

    (2)一个.java源文件中可以声明多个类,但是只能有一个public修饰的类,文件名要和public修饰的类名保持一致;

    (3)类中可以继续声明类,称为内部类;

    6、eclipse的使用

    6.1 默认界面效果

    6.2 创建项目

    (1)在包资源管理器中点右键,选择:

    (2)在src目录上右键,新建package,包的命名规范:

    域名的倒置,例如:www.baidu.com 包名 com.baidu.www

    (3)在当前包下,新建Class

    (4)修改字体

    7、注释

    7.1 单行注释

    语法:

    //这一行是注释

    7.2 多行注释

    /*

    * 多行注释

    * 多行注释

    */

    7.3 文档注释

    /**

    * 这是一个测试的类

    * @author

    *

    */

    练习

    声明两个变量,例如:

    int a,b;

    a = 1;

    b = 2;

    把变量a和变量b的值交换。

    答案:

    int a,b,c;

    a = 1;

    b = 2;

    c = a;

    a = b;

    b = c;

    System.out.println("a="+a);//+ 是拼接的意思

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

    二、Java的基本数据类型

    Java的基本数据类型有4类8种,

    类型分别为:整数型、浮点型、字符型、布尔型;

    其中整数型有4种,字节型byte、短整型short、整数型int、长整型long;

    浮点型有2种:单精度float、双精度double;

    字符型char;

    布尔型boolean

    1、整数型

    整数型取值范围:

    System.out.println("字节类型byte取值范围:");

    System.out.println(Byte.SIZE+"位");

    System.out.println("byte最大:"+Byte.MAX_VALUE);

    System.out.println("byte最小:"+Byte.MIN_VALUE);

    System.out.println("短整型short取值范围:");

    System.out.println(Short.SIZE+"位");

    System.out.println("Short最大:"+Short.MAX_VALUE);

    System.out.println("Short最小:"+Short.MIN_VALUE);

    System.out.println("整数型int取值范围:");

    System.out.println(Integer.SIZE+"位");

    System.out.println("int最大:"+Integer.MAX_VALUE);

    System.out.println("int最小:"+Integer.MIN_VALUE);

    System.out.println("长整型long取值范围:");

    System.out.println(Long.SIZE+"位");

    System.out.println("long最大:"+Long.MAX_VALUE);

    System.out.println("long最小:"+Long.MIN_VALUE);

    2、浮点型

    整数型取值范围:

    System.out.println("单精度浮点型float取值范围:");

    System.out.println(Float.SIZE+"位");

    System.out.println("float最大:"+Float.MAX_VALUE);

    System.out.println("float最小:"+Float.MIN_VALUE);

    System.out.println("双精度浮点型double取值范围:");

    System.out.println(Double.SIZE+"位");

    System.out.println("double最大:"+Double.MAX_VALUE);

    System.out.println("double最小:"+Double.MIN_VALUE);

    3、字符型

    char类型是一个单一的16位Unicode字符,在Java底层是以整数型进行运算;

    最大值:char d = 'uffff';

    最小值:char c = 'u0000';

    4、布尔型

    boolean表示逻辑运算的结果,值为true或false

    boolean a = true;//真

    boolean b = false;//假

    5、数据类型转换

    5.1 自动类型转换

    int a = 1;

    long b = a;//小类型转大类型,自动类型转换

    5.2、强制类型转换

    int a = 127;

    byte b =(byte) a;//大类型转小类型,需要强制类型转换

    练习

    把123.456789,使用当前所学的知识,计算四舍五入保留2位小数的结果。

    答案:

    double d = 123.456789;//保留2位小数

    System.out.println((int) (d*100+0.5)/100.0);

    三、运算符


    1、算术运算符

    重点掌握:取模(%)、自增自减(++a,a++)

    示例代码:

    int a = 1;

    a++;// 自身增加1 , a = a; a=a+1

    ++a;// 自身增加1, a = a+1 ; a = a

    System.out.println(a++); // 在打印的时候,执行的是a = a,所以打印的结果为1 ,打印结束后 a = a+1;

    System.out.println(a);

    System.out.println(++a); // 在打印的时候同时执行了 a = a + 1,所以结果为2,打印结束后又执行了 a=a;

    System.out.println(a);

    2、关系运算符(条件运算)

    3、赋值运算

    4、逻辑运算符

    5、位运算

    代码示例:

    // boolean a = 1>2; // false

    // boolean b = 1==1;// true

    //

    // System.out.println(a & b);//短路与

    // System.out.println(a | b);//短路或

    // int a = 3;// 转为二进制:11

    // int b = 2;// 转为二进制:10

    char a = 'a';// 97 --> 1100001

    char b = 'b';// 98 --> 1100010

    // 1100000 --> 96

    // 1100011 --> 99

    // 0000011 --> 3

    System.out.println(a & b);// & 表示对应位都为1,结果为1,否则为0

    System.out.println(a | b);// | 表示对应位都为0,结果为0,否则为1

    System.out.println(a ^ b);// ^ 表示对应位相同,结果为0,否则为1

    异或(^)作为逻辑运算符时,符号两边相同时返回false,两边不同时返回true;

    6、条件运算符

    语法:

    变量类型 变量名 = 条件 ? A : B ;

    解读:

    声明一个变量,当条件为true时,当前变量的值为A,当条件为false时,当前变量的值为B;

    代码示例:

    int a = false ? 1 : 0;

    System.out.println(a);

    int week = 6;

    String s = (week>=1 && week<=5) ? "去上课":"去LOL";

    System.out.println(s);

    四、流程控制

    1、分支语句

    1.1 if-else-if

    语法:

    if(条件){

    当条件为true时,执行大括号内的代码

    }else if(条件){

    }

    补充:

    //实例化扫描仪对象

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入第一个值:");

    int a = sc.nextInt();

    System.out.println("请输入第二个值:");

    int b = sc.nextInt();

    System.out.println("求和结果:"+(a+b));

    // String s = sc.next();

    // System.out.println(s);

    // double d = sc.nextDouble();

    1.2 switch语句

    概念:

    switch 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。

    语法:

    switch( 变量 ){

    case 值1:

    break;

    case 值2:

    break;

    default:

    }

    当程序执行到break关键字时,跳出当前的switch语句;

    注意事项:

    • switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串类型了,同时 case 标签必须为字符串常量或字面量。
    • switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
    • case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
    • 当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
    • 当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
    • switch 语句可以包含一个 default 分支,该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

    2、循环语句

    2.1 while循环

    语法:

    while(条件){

    当条件为true时,执行循环体内的代码;

    }

    备注:

    满足循环的三个条件:初始化变量、关系运算、迭代

    2.2 do-while循环

    语法:

    do{

    }while(条件);

    备注:与while循环的区别是,当条件为false时,也会被执行一次。

    2.3 for循环

    语法:

    for(int i = 0 ; i < 10 ; i++){

    }

    2.4 嵌套for循环

    2.4.1 打印直角三角形

    for(int i = 1 ; i < 10 ; i++){

    for(int j = 1 ; j <= i ; j++){

    System.out.print("* ");

    }

    System.out.println();

    }

    for(int i = 1 ; i < 10 ; i++){

    for(int j = 1 ; j <=(10-i) ; j++){

    System.out.print("* ");

    }

    System.out.println();

    }

    2.4.2 打印乘法口诀

    for(int i = 1 ; i < 10 ; i++){

    for(int j = 1 ; j <=i ; j++){

    System.out.print(j+"×"+i+"="+(i*j)+"t");

    }

    System.out.println();

    }

    for(int i = 1 ; i < 10 ; i++){

    for(int j = 1 ; j <=(10-i) ; j++){

    System.out.print(i+"×"+j+"="+(i*j)+"t");

    }

    System.out.println();

    }

    for(int i = 1 ; i < 10 ; i++){

    for(int j = 1 ; j < i ; j++){

    System.out.print("t");

    }

    for(int j = i ; j < 10 ; j++){

    System.out.print(i+"×"+j+"="+(i*j)+"t");

    }

    System.out.println();

    }

    for(int i = 1 ; i < 10 ; i++){

    for(int j = 1 ; j < 10-i ; j++){

    System.out.print("t");

    }

    for(int j = 1 ; j <=i ; j++){

    System.out.print(j+"×"+i+"="+(i*j)+"t");

    }

    System.out.println();

    }

    2.5 循环控制

    2.5.1 break语句

    break 可以用于所有的循环语句或者 switch 语句中,用来跳出整个语句块。

    break 跳出该关键字所在的循环,并且继续执行该循环下面的语句。

    2.5.2 continue语句

    continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

    在 for 循环中,continue 语句使程序立即跳转到更新语句。

    在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。

    2.6 标签的使用

    语法:

    标签名 :

    使用:

    break 标签名; 或

    continue 标签名;

    示例:

    a: for (int i = 1; i <= 10; i++) {

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

    b: for (int j = 1; j <= 10; j++) {

    if(j==5){

    // continue a;

    break a;

    }

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

    }

    }

    注意:

    标签名的语法规则要遵循标识符的语法要求;

    break 标签名 : 跳出该标签名后面的循环;

    continue 标签名: 跳过该标签名的本次循环,继续进行下次迭代;

    补充(随机数)

    生成随机数(2位)

    Random ran = new Random();

    int i = ran.nextInt(90)+10; // 随机的结果为 [0,90)+10 = [10,99]

    System.out.println(i);

    五、数组

    1、数组的声明

    (1)语法:

    类型[] 数组名 = new 类型[长度];

    示例:

    int[] array = new int[10];

    (2)语法:

    类型[] 数组名 = {值,值,……};

    示例:

    int[] array2 = {1,2,3,4,5,6,7,8,9,10};

    (3)语法:

    类型[] 数组名 = new 类型[]{值,值……};

    示例:

    int[] array3 = new int[]{1,2,3,4,5,6,7,8};

    数组通过下标来赋值和取值,例如:

    array[0] = 1;

    System.out.println(array[0]);

    下标的范围是从0开始,到数组的长度-1;

    2、数组的遍历

    示例:

    int[] array = {10,12,32,45,57,68,79,80,90,100,200,300};

    //数组的遍历

    for(int i = 0 ; i < array.length ; i++){

    System.out.println(array[i]);

    }

    增强for循环:

    语法:

    for(数组类型 变量名 : 数组名){

    System.out.println(变量名);

    }

    示例:

    int[] a = {1,2,3,4,5,6};

    //增强for循环

    for(int i : a){

    System.out.println(i);

    }

    3、数组排序

    3.1 冒泡排序

    从后往前依次确定元素,相邻的两个元素比较,互换位置;

    int[] a = {3,7,9,1,5};

    for(int i = 1 ; i < a.length ; i++){

    for(int j = 0 ; j < a.length - i; j++){

    if(a[j] < a[j+1]){

    int temp = a[j];

    a[j] = a[j+1];

    a[j+1] = temp;

    }

    }

    }

    3.2 选择排序

    从前往后确定元素,让未确定的第一个数依次和后面的比较,互换位置;

    int[] a = { 3, 7, 9, 1, 5 };

    for (int i = 0; i < a.length - 1; i++) {

    for (int j = i + 1; j < a.length ; j++) {

    if (a[i] < a[j]) {

    int temp = a[i];

    a[i] = a[j];

    a[j] = temp;

    }

    }

    }

    4、二维数组

    示例:

    int[] a = {1,2,3,4,5,20};

    int[] b = {6,7,8,9,10};

    int[] c = {11,12,13,14,15,16,17,18};

    //二维数组

    int[][] array = {a,b,c};

    //遍历array

    for(int i = 0 ; i < array.length ; i++){

    for(int j = 0 ; j < array[i].length; j++){

    System.out.print(array[i][j]+" ");

    }

    System.out.println();

    }

    六、方法

    1、方法的声明

    语法:

    [访问修饰符] [static] 返回值类型 方法名(参数列表){

    要执行的代码

    }

    示例:

    //自定义方法

    public static void print(){

    System.out.println("hello");

    }

    1.1 static关键字

    用法:

    • 当使用static关键字修饰方法时,该方法称为静态方法,即类的方法;
    • 如果没有使用static关键字修饰,该方法为普通方法(实例方法),即对象的方法;
    • 静态方法中,只能直接调用静态方法;
    • 实例方法中,可以直接调用静态方法,也可以直接调用实例方法;
    • 静态方法中如果要调用实例方法,必须先实例化对象,使用对象名调用;

    补充:

    实例化对象语法:

    类名 对象名 = new 类名();

    1.2 void关键字

    • 当方法没有任何返回值时,方法声明语句中使用void关键字;
    • 当方法有返回值时,返回值是什么数据类型,就声明为什么类型;

    1.3 参数

    语法:

    • 在方法名后面的括号中声明;
    • 参数的个数为大于等于0;
    • 写法:方法名(类型 变量名,类型 变量名,……){}
    • 参数是当前方法的局部变量,是一种特殊的局部变量;
    • 参数的赋值过程,是在调用该方法时完成的;
    • 当有多个参数,调用该方法时,依次按照括号中的顺序为参数赋值;
    • 参数的类型可以为Java的任何数据类型;

    2、使用方法的好处

    (1)提高代码的复用性,减少代码量;

    (2)把某个功能封装到一个方法中,便于协作开发;

    (3)便于代码集中管理;

    (4)提现了面向对象的思想;

    3、方法重载

    概念:重载(overloading) 是在一个类里面,方法名字相同,而参数不同。与返回值类型、访问修饰符无关。

    规则:

    (1) 参数的类型不同;

    (2) 参数个数不同;

    (3) 参数的顺序不同;

    七、面向对象

    万物皆对象

    描述一个物质都可以通过两方面说明:数据模型(属性)、行为模型(行为)。

    在Java编程中,我们使用成员变量表示数据模型,用成员方法表示行为模型。

    使用类表示某些具有相同属性和行为的事物。

    以动物为例:

    1、构造方法

    语法:

    [访问修饰符] 类名(){

    }

    注意:

    当类中没有显式的构造方法,实例化该类的对象时,程序会自动创建一个公开的无参构造方法;

    如果类中有显示的构造方法,程序就不会创建无参构造;

    构造方法,一般是用于为成员属性赋初始化值;

    2、变量

    2.1 局部变量

    • 声明在构造方法、静态方法、实例方法、代码块中的变量,都是局部变量;
    • 不能使用static和访问修饰符修饰;
    • 可以使用final修饰,即为常量,不必在声明语句中赋值;
    • 当执行局部变量所在的方法或代码块时,才有机会被创建,在方法或代码块执行结束后被自动销毁;
    • 局部变量在内存的栈区分配;
    • 局部变量在使用之前必须要先赋值;
    • 声明在所有方法体和代码块之外,并且没有使用static修饰的变量,叫做实例变量;
    • 可以使用访问修饰符和final修饰;
    • 使用final修饰时,一定要赋值;
    • 实例变量是在对象被创建时创建,对象被销毁时销毁;
    • 作用域范围在整个类中;
    • 声明在所有方法体和代码块之外,并且使用static修饰的变量;
    • 可以使用访问修饰符修饰;
    • 一般配合final使用,即public static fianl,标识符使用大写;
    • 类变量被分配在静态存储区,是被所有该类的对象共享数据;
    • 类变量是在程序开始时被创建,程序结束时销毁;

    2.2 实例变量

    2.3 类的变量

    3、访问修饰符

    访问修饰符是用来控制其他类对该类的类、实例变量、构造方法、实例方法的访问权限。Java的访问权限有4种:

    public 公开的

    protected 受保护的

    默认的,没有任何关键字来表示

    private 私有的

    修饰符

    当前类

    同包的类

    同包的子类

    异包

    异包的子类

    public

    protected

    ×

    ×

    默认的

    ×

    ×

    private

    ×

    ×

    ×

    ×

    4、this关键字

    this指当前对象,用法:

    • 当局部变量名和实例变量名同名时,使用this.变量名来表示实例变量;
    • this()表示当前类的构造方法,只能在构造方法中使用该写法,并且是写在构造方法内的第一行。

    5、封装

    私有的属性,公开的方法。

    封装的步骤:

    声明私有(private)的属性;

    声明公开(public)的geter和seter方法;

    6、继承

    Java中的继承是单继承,可以实现多层继承,继承的关键字extends

    语法:

    public class Son extends Father{

    }

    规则:

    • 子类继承父类非私有的所有属性和方法,不能继承父类的构造方法;
    • 实例化子类对象的步骤:先执行父类的构造方法,再执行子类的构造方法;

    重写定义:

    • 子类重新声明从父类继承来的方法,称为方法重写;
    • 方法重写时,方法的声明部分要和父类保持一致(返回值类型,方法名,参数);
    • 重写方法的访问权限要大于等于父类中方法的访问权限;
    • 子类重写父类方法,子类对象调用的是子类中重写后的方法;
    • 使用static修饰的方法不能被重写,但是可以被子类重写声明;
    • 不同包的子类可以重写父类中protected修饰的方法,但是不能以继承的形式,用子类对象直接调用父类的该方法;

    Final关键字:

    • 当final修饰类时,当前类不能被继承;
    • 当final修饰方法时,该方法不能被重写;
    • 当final修饰变量时,变量的值不能被修改,即为常量;

    7、多态

    实现的必要条件:

    • 继承
    • 重写
    • 父类引用指向子类对象

    instanceof关键字:

    语法:

    if (对象名 instanceof 类名) {

    类型转换代码;

    }

    实例:

    Animal cat = new Cat();

    if (cat instanceof Cat) {//返回结果为boolean类型

    Cat c = (Cat) cat;

    c.eat();

    }else{

    System.out.println("类型不匹配");

    }

    8、抽象类

    抽象类语法:

    public abstract class Demo {

    }

    抽象方法语法:

    public abstract void abc();

    规则:

    含有抽象方法的类,一定是抽象类;

    • 抽象类中可以声明成员变量、常量、成员方法、抽象方法,抽象类中不一定要有抽象方法;
    • 抽象类不能被实例化;
    • 抽象类可以被继承;
    • 可以通过两种方式获得抽象类对象:父类引用指向子类对象、匿名内部类;
    • 子类必须重写抽象父类的所有抽象方法,或者是把子类也定义为抽象类;
    • 如果一个类继承的抽象父类还有上级抽象父类,那么子类中需要要重写所有抽象父类的所有抽象方法;
    • 抽象类也可以继承非抽象类,同时继承了父类的所有非私有的属性和方法;

    9、接口

    语法:

    public interface ITest {

    }

    规则:

    • 接口使用interface关键字修饰;
    • 接口是一个完全抽象的抽象类;
    • 接口中没有构造方法;
    • 接口不能被实例化对象;
    • 接口中可以声明静态常量、抽象方法、静态方法;
    • 接口中不能声明实例方法,声明抽象方法时,不能使用static关键字修饰;
    • 声明接口语句中,默认含有abstract关键字,抽象方法中也默认含有abstract关键字;
    • 接口可以被实现,使用implements关键字,一个类实现一个接口,必须重写该接口中所有的抽象方法;
    • 一个类可以实现多个接口,每个接口名用英文的逗号隔开,该类中必须重写所有已实现接口中的抽象方法;
    • 接口可以继承接口,接口与接口间是多继承关系,接口不能继承类;

    10、内部类

    10.1 成员内部类

    成员内部类声明在类中,方法体、代码块之外。和成员变量、成员方法在同一级别。

    语法:

    public class Out {

    //成员内部类

    public class Inner{

    }

    }

    实例化成员内部类:

    //先实例化外部类

    Out o = new Out();

    //使用外部类对象,再实例化内部

    Out.Inner inner = o.new Inner();

    实例:

    public class Out {

    //成员变量

    public int a = 1;

    //成员内部类

    public class Inner{

    public int a = 2;

    //内部类的成员方法

    public void print(){

    //执行内部类中的实例变量a

    System.out.println(a);

    //执行外部类的实例变量a

    System.out.println(Out.this.a);

    }

    }

    }

    10.2 静态内部类

    声明的位置参考成员内部类。

    语法:

    public class Out {

    //静态内部类

    public static class Inner{

    }

    }

    实例化静态内部的对象:

    Out.Inner inner = new Out.Inner();

    实例:

    public class Out {

    public static int a = 1;

    public int b = 3;

    //静态内部类

    public static class Inner{

    public static int a = 2;

    public static void print(){

    //执行静态内部的静态变量

    System.out.println(a);

    //执行外部类的静态变量

    System.out.println(Out.a);

    //执行外部类的实例变量

    Out o = new Out();

    System.out.println(o.b);

    }

    }

    }

    10.3 局部内部类

    声明在方法体或代码块内,作用域范围在方法体或代码块内。

    语法:

    public class Out {

    public void method(){

    //局部内部类

    class Inner{

    //局部内部类的成员方法

    public void print(){

    System.out.println("局部内部类");

    }

    }

    //实例化局部内部类

    Inner inner = new Inner();

    inner.print();

    }

    }

    执行局部内部类的方法:

    Test类:

    public static void main(String[] args) {

    Out o = new Out();

    o.method();

    }

    10.4 匿名内部类

    • 声明位置同局部内部类一样,前提条件:必须继承一个类或实现一个接口,匿名内部类的声明和实例化对象是同时进行的;
    • 一般使用于获得抽象类或接口对象;

    语法:

    父类名/接口名 对象名 = new 父类名/接口名(){

    //匿名内部类成员

    };

    实例:

    父类

    public class Father {

    }

    匿名内部类:

    public class Out {

    public void method(){

    //匿名内部类对象

    Father f = new Father(){

    };

    }

    }

    八、Java常用类库

    1、Object类

    Object类是所有类直接或间接父类。

    方法:

    toString():以字符串形式返回对象的文本信息;

    hashCode():返回该对象的哈希值;

    getClass():返回对象的类类型;

    equals(Object obj):比较两个对象是否相等

    2、包装类

    2.1 装箱与拆箱

    实例:

    byte b = 1;//基本数据类型

    System.out.println(b+1);

    Byte b2 = new Byte(b);//包装类的对象

    System.out.println(b2);

    Byte b3 = b;//自动装箱,把基本数据类型转为对象

    System.out.println(b3+5);

    byte b4 = new Byte(b);//自动拆箱,把对象转为基本数据类型

    System.out.println(b4+7);

    2.2 Number类的常用方法

    • 构造方法;
    • valueOf();
    • toString();

    2.3 Character 常用方法

    • valueOf();
    • toString();
    • isDigit():判断是否为数字
    • isLetter():判断是否为字母
    • isUpperCase():判断是否为大写字母
    • isLowerCase():判断是否为小写字母
    • isWhitespace():判断是否为空格
    • toUpperCase():转为大写字母
    • toLowerCase():转为小写字母

    3、字符串操作

    3.1 String类

    String字符串的值不可更改。

    常用方法:

    • charAt(int i):返回指定索引处的字符;
    • length():返回字符串的长度;
    • contains(CharSequence c):判断字符串中是否包含指定的字符序列;
    • startsWith(String s):判断字符串是否以指定的前缀开始;
    • endsWith(String s):判断字符串是否以指定的后缀结束;
    • indexOf(char c):返回指定字符在字符串中第一次出现的索引;
    • lastIndexOf(char c):返回指定字符在字符串中最后一次出现的索引;
    • isEmpty():当且仅当字符串长度为0时,返回true;
    • replace(char old,char new):把字符串中的old字符替换为new字符,然后返回一个新字符串;
    • split(String s):根据指定的规则拆分字符串,返回字符串数组;
    • subString(int begin,int end):按照指定的索引截取字符串,从begin(包含)开始,到end(不包含)结束;
    • toLowerCase():把字符串的英文字母全部转为小写;
    • toUpperCase():把字符串的英文字母全部转为大写;
    • trim():清除字符串前后的空白字符;
    • valueOf():把指定类型的数据转为字符串类型;
    • toCharArray():把字符串转为字符数组;

    3.2 可变字符序列

    StringBuffer和StringBuilder都是可变的字符序列,唯一的区别:StringBuffer是线程安全的,StringBuilder是线程不安全;

    常用方法:

    • append():追加;
    • toString():把所有追加的内容以String类型返回;

    4、System类

    常用方法:

    currentTimeMillis():获得当前时间戳,以毫秒为单位

    exit(0):正常终止JVM

    5、时间日期操作

    5.1 时区操作(了解)

    实例:

    /*

    * 获取可用时区ID的方法

    */

    //获得时区对象的方法

    // TimeZone t = TimeZone.getDefault();

    //获取可用的所有ID

    String[] ids = TimeZone.getAvailableIDs();

    for (String id : ids) {

    //获得每次遍历ID的时区对象

    TimeZone tz = TimeZone.getTimeZone(id);

    System.out.println(id+"------>"+tz.getDisplayName());

    }

    //根据时区ID获得时区对象

    TimeZone tz = TimeZone.getTimeZone("Africa/Abidjan");

    //设置时区

    TimeZone.setDefault(tz);

    //根据时间戳获得指定日期对象

    long time = 0;

    Date d = new Date(time);

    System.out.println(d);

    5.2 Date类

    构造方法:

    • Date():创建日期对象;
    • Date(long t):根据时间戳创建日期对象;

    常用方法:

    • after(Date d):当前日期对象是否在指定日期之后;
    • before(Date d):当前日期对象是否在指定日期之前;
    • getTime():获得当前的时间戳;
    • setTime(long t):设置时间对象的具体时间为指定的时间戳;

    5.3 Calendar类

    实例:

    //获得日历对象

    Calendar c = Calendar.getInstance();

    int year = c.get(Calendar.YEAR);//获得年份

    System.out.println(year);

    int month = c.get(Calendar.MONTH);//获得月份

    System.out.println(month+1);

    int day = c.get(Calendar.DAY_OF_MONTH);//获得月份中的日期

    System.out.println(day);

    int week = c.get(Calendar.DAY_OF_WEEK);//星期几

    System.out.println(week-1);

    // int s = c.get(Calendar.HOUR);//12小时制的时

    int s = c.get(Calendar.HOUR_OF_DAY);//24小时制的时

    System.out.println(s);

    int f = c.get(Calendar.MINUTE);//小时的分钟数

    System.out.println(f);

    int m = c.get(Calendar.SECOND);//秒

    System.out.println(m);

    int hm = c.get(Calendar.MILLISECOND);//毫秒

    System.out.println(hm);

    常用方法:

    • add(int field,int value):计算时间日期的偏移量;
    • getTime():获得Date类型的日期对象;
    • getTimeInMillis():获得时间戳;
    • get(int field):获得时间数据;
    • set(int field,int value):设置具体的时间;
    • set(year,month,day,hour,minute,second):通过参数直接设置具体时间;
    • setTime(Date d):把Date类型转为Calendar类型;

    Calendar的子类GregorianCalendar,是格里高利日历,常用的方法:

    • isLeapYear(int year):判断指定年份是否为闰年,是闰年返回true;

    5.4 日期格式化

    1.格式化日期

    实例:

    // Date d = new Date(0);

    SimpleDateFormat sdf = new SimpleDateFormat("y年M月dd日 HH:mm:ss");

    System.out.println(sdf.format(new Date()));

    2.解析日期

    实例:

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入一个日期:");

    String str = sc.next();

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");

    //把字符串类型的日期解析为Date对象

    Date d = sdf.parse(str);

    System.out.println(d);

    注意解析的模式是否正确,防止抛出解析异常

    6、Math类

    Math类是数学相关的操作工具类

    7、Random类

    获取伪随机数的类

    8、Scanner类

    获得用户在控制台输入的内容

    9、Desktop类

    使用Java程序执行本机的应用程序

    执行浏览器实例:

    // URI uri = new URI("http://www.baidu.com");

    //获得本机对象

    // Desktop d = Desktop.getDesktop();

    // d.browse(uri);

    //简化

    Desktop.getDesktop().browse(new URI("http://www.taobao.com"));

    执行本地应用程序实例:

    //执行本地应用程序

    Desktop.getDesktop().open(new File("F:/a.txt"));

    10、正则表达式

    正则符号:

    含义

    符号

    数字

    [0-9] d

    字母

    [a-zA-Z]

    空白字符

    [ ntrfx0B]

    表示非

    [^规则]

    任意字符(换行除外)

    . (点)

    正则开始

    ^

    正则结束

    $

    正则数量:

    符号

    含义

    +

    n≥1 1到多个

    *

    n≥0 0到多个

    ?

    0≤ n ≤1 0或1个

    {n}

    n个

    {n,}

    n ≤ n到多个

    {n,m}

    n≤ num ≤m n到m个

    正则逻辑:

    含义

    符号

    分组

    ()

    |

    什么都不写

    实例:

    验证手机号:

    //手机号是11位数字,前3位是136/130开头,后8位是随机数字

    String str = "13033338880";

    //规则

    String gz = "^(([1][3][6])|([1][3][0]))([0-9]{8})$";

    boolean rel = str.matches(gz);

    if(rel){

    System.out.println("ok");

    }else{

    System.err.println("no");

    }

    邮箱验证:

    //邮箱 zhangsan_.abc@qq.com为例,前缀:字母、数字、下划线、点、减号,@,qq/126/139/sina,com/http://com.cn/org/cn

    String str = "adf123@qq.cn";

    //规则

    String gz = "^([0-9a-zA-Z_.-]{3,18})"

    + "[@]"

    + "(([q]{2})|([1][2][6])|([1][3][9])|([s][i][n][a]))[.]"

    + "(([c][o][m])|([c][n])|([c][o][m][.][c][n]))$";

    boolean rel = str.matches(gz);

    if(rel){

    System.out.println("ok");

    }else{

    System.err.println("no");

    }

    展开全文
  • java面试题之java基础1. JDK 和 JRE 有什么区别?JDK:java development kit :java开发工具包,是程序员使用java语言编写java程序所需的开发工具包,JDK包含JRE,同时还包含了编译java源码的编译器javac,还包含了...

    0d4992c1fc35f974e9fab524b560f844.png

    java面试题之java基础

    1. JDK 和 JRE 有什么区别?

    JDK:java development kit :java开发工具包,是程序员使用java语言编写java程序所需的开发工具包,JDK包含JRE,同时还包含了编译java源码的编译器javac,还包含了很多java程序调试和分析的工具。

    JRE:java Runtime Environment :java的运行环境,包含了java的虚拟机,java的基础类库,是使用java语言编写程序运行所需要的软件环境。

    2. == 和 equals 的区别是什么?

    == 是判断两个变量或实例是不是指向同一个内存空间,== 是java的一个运算符合

    Equals 是判断两个变量和实例所指向的内存空间的值是不是相同,Equals是java的一个方法

    3. 两个对象的 hashCode()相同,则 equals()也一定为 true,对吗?

    如果equals相等,则hashCode一定相等,反之则不然,两个方法的关联:

    A.equals(B)==ture --> A.hashCode() == B.hashCode()

    两个方法的定义:

    Equals():用来判断两个对象是否相等,相同返回true,不相同返回false。

    hashCode():返回一个int数,该int数的含义是:将该对象的内部地址转换为一个整数返回。

    两个方法的规范:

    1.若重写equals(Object obj)方法,必须重写hashcode()方法,确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。

    2.如果equals(Object obj)返回false,即两个对象“不相同”,并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是:“如果两个对象不相同,他们的hashcode可能相同”。

    hashCode是所有java对象的固有方法,如果不重载的话,返回的是该对象在jvm的堆上的内存地址,而不同对象的内存地址肯定不同,所以这个hashCode也就肯定不同。

    哈希表是结合了直接寻址和链式寻址两种方式,将需要加入哈希表的数据首先计算哈希值,哈希值就是预先分个组,然后再将数据挂到分组后的链表后面,随着添加的数据越来越多,分组链上会挂接更多的数据,同一个分组链上的数据必定具有相同的哈希值,java中的hash函数返回的是int类型的,也就是说,最多允许存在2^32个分组,也是有限的,所以出现相同的哈希码就不稀奇。

    4. final 在 java 中有什么作用?

    特征:凡是引用final关键字的地方皆不可修改

    1.修饰类:类不能被集成

    2.修饰方法:方法不能被重写

    3.修饰参数:参数不能被修改

    5. java 中的 Math.round(-1.5) 等于多少?

    1.round(arg):返回arg的四舍五入值,负.5返回较大的整数,如-0.5返回-1。

    2.ceil(arg):返回小数所在两整数之间的最大值,如-0.5返回-1。

    3.tail(arg):返回小数所在两整数之间的最小值,如-0.5返回-2。

    6. String 属于基础的数据类型吗?

    不是,java是用final修饰引用数据类型。

    Java的基础数据类型有:byte、short、char、int、long、float、double、boolean

    7. java 中操作字符串都有哪些类?它们之间有什么区别?

    String,StringBuffer,StringBuilder。

    相同点:都是以char[]的方式保存字符串。

    不同点:

    String类型的字符串是不可变的,我们对String的任何操作都相当于new一个新的String 。

    StringBuffer和StringBuilder进行增删操作都是对一个对象做操作

    StringBuffer中的方法大多数都使用synchronized关键字修饰,所以StringBuffer是线程安全的。

    StringBuilder的方法没有用synchronized进行修饰所以线程不安全,但是正因为如此,所以他的性能更高。

    使用:

    单线程的情况下使用StringBuilder

    多线程的情况下使用StringBuffer

    如果在一个生命周期内,这个字符串几乎不做什么操作,那使用String,因为不调用new关键字声明Sting时,他不会再堆内存中创建对象,直接指向String的常量值,并可以复用,效率更高。

    8. String str="i"与 String str=new String(“i”)一样吗?

    不一样,因为内存的分配方式不一样。

    String str="i"的方式,Java 虚拟机会将其分配到常量池中;

    而 String str=new String(“i”)方式,则会被分到堆内存中。

    9. 如何将字符串反转?

    StringBuffer的reverse()方法。

    String的charAt()方法从后向前取出。

    10. String 类的常用方法都有那些?

    .length()获取长度。

    .charAt(int index)返回指定索引的字符。

    .substring(2)截取。

    .compareTo(str2)比较。

    .concat(String str)连接。

    .toLowerCase()小写。

    .toUpperCase()大写。

    .replace(char oldChar, char newChar)替换。

    11. java 中 IO 流分为几种?

    1.如果按流的流向分,可分为输入流和输出流。

    2.如果按流的单元分,可分为字节流和字符流。

    3.按照流的角色划分,可分为节点流和处理流。

    InputStream:字节输入流的基类,OutputStream:字节输出流的基类。

    Reader:字符输入流的基类,Writer:字符输出流的基类。

    12. BIO、NIO、AIO 有什么区别?

    默认情况:服务端启动一个ServerSocket,客户端启动Socket来对服务端进行通信。

    BIO (Blocking I/O): 同步阻塞I/O

    1.服务器实现模式为一个连接一个线程。即客户端有连接请求时服务器就需要启动一个线程进行处理

    2.如果这个连接不做任何事情会造成不必要的线程开销

    3.适用于连接数目比较小且固定的架构,这种方式对服务端资源要求比较高,应对小于单机1000的并发量。

    NIO (New I/O): 同步非阻塞的I/O

    1.服务器实现模式为一个请求一个线程。即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有IO请求时才启动一个线程进行处理。

    2.适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器

    AIO (Asynchronous I/O): 异步非阻塞I/O

    1.服务器实现模式为一个有效请求一个线程。客户端的IO请求都是由操作系统先完成了再通知服务器用其启动线程进行处理

    2.适用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用OS参与并发操作,编程比较复杂。

    13. 同步与异步的区别:

    同步:发送一个请求,等待返回,再发送下一个请求,同步可以避免出现死锁,脏读的发生

    异步:发送一个请求,不等待返回,随时可以再发送下一个请求,可以提高效率,保证并发

    14. Files的常用方法都有哪些(NIO包下)?

    1.Files.exists():检测文件路径是否存在。

    2.Files.createFile():创建文件。

    3.Files.createDirectory():创建文件夹。

    4.Files.delete():删除一个文件或目录。

    5.Files.copy():复制文件。

    6.Files.move():移动文件。

    7.Files.size():查看文件个数。

    8.Files.read():读取文件。

    9.Files.write():写入文件。

    展开全文
  • 标识符不能是java关键字和保留字,java严格区分大小写;标点符号均是英文状态下输入;变量:变量类型,变量名,变量值; 变量类型(数据类型):基本数据类型,引用数据类型; 基本数据类型:存储数据本身,如抽屉...

    88a8bf006473bf020f6efd6497868fbf.png

    JAVA学习笔记

    标识符:标识符只能有字母,数字,下划线和$组成,不能保护@%空格等特色字符,切记不能以数字开头;

    标识符不能是java关键字和保留字,java严格区分大小写;标点符号均是英文状态下输入;

    变量:变量类型,变量名,变量值;

    变量类型(数据类型):基本数据类型,引用数据类型;

    基本数据类型:存储数据本身,如抽屉存放物品

    数值型:

    整数类型:byte short int long;用于存储整数

    如:int age=21;

    浮点类型:float double; 用于存储小数

    如:double price=15.5;float height=175.2f;此处注意添加字母f;

    字符型:char;用于存储单个字符,如性别'男'、'女',

    如:char sex='男';此处注意为单引号

    布尔型:boolean;表示"真"或"假",取值只能是true或false;

    如:boolean flag=true;

    引用数据类型:存储数据的空间地址,如抽屉存放另一抽屉的钥匙

    类:class;

    接口:interface;

    数组:

    变量名:由字母,数字,下划线和$组成,不能以数字开头;

    优秀习惯:骆驼式命名(驼峰式)如 myAge;见名知意;

    变量值:赋予变量的值,如:int age=21;此处21为变量age的变量值;

    变量的使用规则:

    Java中的变量需要先声明后使用

    public class HelloWorld{

    public static void main(String[] args){

    System.out.println("变量love的内容是:"+love);

    }

    }

    此处的变量love未声明,需要在第二行加入 String love="我爱你"即可;

    变量使用时,可以声明变量的同时进行初始化:

    String love="我爱你";

    变量使用时,也可以先声明后赋值:

    String love;

    love="我爱你";

    变量每次只能赋一个值,但可以修改多次

    String love="我爱你","我不爱你";显示为输入错误;

    变量可以多次修改,最终输出结果为最后一次赋值;

    String love="我爱你";

    String love="我不爱你";

    main方法中定义的变量必须先赋值,然后才能输出

    String love;

    System.out.println(love);

    此处变量love在输出前必须先赋值

    虽然语法中没有提示错误,但在实际开发中,变量名不建议使用中午,容易产生安全隐患,譬如后期跨平台操作时出现乱码等等,

    String 姓名="张三",不建议此中文变量;

    Java中的类型转换:自动类型转换,强制类型转换

    自动类型转换:不同的基本数据类型的数据之间经常需要进行相互转换。

    如: int score1=82;

    double score2=score1;

    System.out.println(score2);

    代码中int型变量可以直接转换为double型变量,运行结果为82.0,这种转换称为自动转换。

    自动转换需满足条件

    目标类型能与源数据类型兼容,如double型兼容int型,但是char型不能兼容int型,显示赋值错误;

    目标类型大于源类型,如double型长度为8字节,int型为4字节,因此double类型的变量里直接可以存放int类型的数据,但是反过来就不可以自动转换了,需要强制转换,会导致小数部分数据的缺失;

    强制类型转换:

    语法(数据类型)数值

    double avg1=75.8;

    int avg2=(int)avg1;

    System.out.println(avg1);

    System.out.println(avg2);

    运行结果:75.8、75,注意不是四舍五入,直接丢失小数部分;

    Java常量的应用

    所谓常量,一种特殊的变量,它的值被设定后,在程序运行过程中不允许改变。

    语法:final 常量名=值;

    final String LOVE="我爱你";

    final double PI=3.14;

    程序中使用的常量可以提高代码的可维护性。

    注意:常量名一般使用大写字符

    Java中使用注释:一般注释应该占到源代码的1/3以上,重要组成部分,加以重视;

    注释的三种类型:单行注释,多行注释,文档注释。

    文档注释以/**开头,以*/结尾

    展开全文
  • java 两个整数相除保留位小数

    千次阅读 2019-08-31 16:15:26
    java中,当两个整数相除时,由于小数点以后的数字会被截断,运算结果将为整数,此时若希望得到运算结果为浮点数,必须将两整数其或是两者都强制转换为浮点数。 例如: (float)a/b // 将整数其中个强制转换为...
  • 有时需要在输入框加入输入数据的小数点位数控制,比如我们只希望用户输入保留一位小数的数据,那么就可以用这个函数来判断输入的数据小数点后位数,当大于1时,弹出提示框 public int checkNum(String str){ if...
  • Java保留位小数的方法

    万次阅读 2018-12-10 12:31:18
    项目中有个小需求,两个整数相除,结果需要保留位小数,即1.00、0.50这种数据格式。 以下做法不行,因为两整数相除,小数点以后的数字会被截断,让运算结果为整数类型, int x = 10; int y = 20; int a = x/y...
  • Java中Double保留小数位的几种方法

    千次阅读 2018-06-08 10:29:36
    最近做个小实验,其中部分要求将表单提交的数据转换为double,这个功能其实很简单直接句Double.parseDouble(request.getParameter("chinese").trim())就可以实现,但因为是统计成绩,所以需要保留...
  • 1.java输入一个char字符 https://zhidao.baidu.com/question/327466502.html Scanner scanner = new Scanner(System.in); System.out.println("是否充值,y or n ?"); if (scanner.nextLine().charAt(0...
  • java保留2位小数及BigDecimal使用 2017年11月17日 13:07:04 擅长发呆 阅读数:30405 java保留位小数的方法 import java.math.BigDecimal; import java.text.DecimalFormat; import java.text.NumberFormat; ...
  • Java两个整数相除,保留N位小数

    千次阅读 2017-03-03 15:48:38
    Java代码如下: float num = (float)1/3; DecimalFormat df = new DecimalFormat("0.0000");//保留4位小数 String s = df.format(num);
  • 这里写自定义目录标题double保留两位小数,如果小数最后一位是0,则保留一位小数 double保留两位小数,如果小数最后一位是0,则保留一位小数 /** * double转换 */ private String doubleTrans(double d) { if (Math...
  • 读入个浮点数,保留 12 位小数,输出这个浮点数。 输入格式 只有行,个浮点数 x(0 ≤ x ≤ 10)。 输出格式 也只有行,保留 12 位小数的浮点数。 Sample Input 3.1415926535798932 Sample Output 3....
  • BigDecimal保留小数位

    千次阅读 2017-10-25 20:45:56
    package com.algorithms;import java.math.BigDecimal; import java.util.Scanner;/** * 调和级数求和 * @author LYY * */ public class TiaoHeJiShuTest { public static void main(String[] args) { System
  • 既然能够判断个数值是否为整数,那么就应该有机会将它的整数部分和小数部分分割开来,也就是我们常说的取整(它同时包含了取小数),在我们初学JAVA时,我们常用的方法是强制转换,或者利用BigDecimal.ROUND语句来...
  • 1.利用DecimalFormat类进行保留小数 float a = 12f; b = 25f; //对数据进行保留两小数 如果是保留四小数就是("0.0000") DecimalFormat b = new DecimalFormat("0.00") String format = b.format(a/b); //...
  • new BigDecimal(i).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue()
  • import java.util.Scanner; public class integer1 { public static void main(String[] args) { float x=0; int i; Scanner r=new Scanner(System.in); x=r.nextFloat(); i=(i...
  • import java.util.Scanner; public class shujutongji { public final static int INF=1000000000; public static void main(String[] args) { // TODO Auto-generated method stub int x,n=0,t=0,s=0; ...
  • 实现保留位小数

    千次阅读 2019-05-29 13:47:52
    import java.util.Scanner; import java.text.DecimalFormat; public class HelloWorld{ public static void main(String [] args ){ Scanner input = new Scanner... System.out.println("请输入个数的值...
  • 个double型数值保留位小数

    万次阅读 2017-03-09 19:52:24
    在处理数值运算的时候,有时候会遇到保留几位小数的需求,下面是... * 将数据保留位小数 */ privatedoublegetTwoDecimal(doublenum) { DecimalFormatdFormat = newDecimalFormat("#.00"); Stringyea...
  • 问题:Java如何获取指定小数位的进位数据? 为了方便,简单的写了个测试类,仅供参考。后续有新的应用再做赘述! package cn.***; import java.math.RoundingMode; import java.text.DecimalFormat; /** * ...
  • 读入个单精度浮点数,保留3位小数输出这个浮点数。 输入 只有行,个单精度浮点数。 输出 也只有行,读入的单精度浮点数。 样例输入 12.34521 样例输出 12.345 #include<stdio.h> int main() { float a...
  • 、网络原理 OSI 与 TCP/IP 各层的结构与功能,都有哪些协议 TCP 建立连接的过程,为什么要三次握手? TCP、UDP 协议的区别,各自的应用场景 打开浏览器,输入 URL 地址,访问主页的过程 HTTP 有哪些方法? HTTP ...
  • 1. 功能 将程序中的double值精确到小数点后两。可以四舍五入,也可以直接截断。 比如:输入12345.6789,输出可以是12345.68也可以是12345.67。至于是否需要四舍五入,可以通过参数来决定(RoundingMode.UP/...
  • 个要分享给大家的就是算法和数据结构 第二个就是数据库的高频知识点与性能优化 第三个则是并发编程(72个知识点学习) 最后个是各大JAVA架构专题的面试点+解析+我的一些学习的书籍资料 802)] 最后个是各大...
  • [0,1] 结果保留位小数 1、0.X ^(0?\\.\\d{1,4})$; 2、0.0X ^(0\\.0?\\d{1,3})$; 3、0.00X ^(0\\.00?\\d{1,2})$; 4、0.000X ^(0\\.000?\\d|)$; 5、0、1、1.0、1.00、1.000、1.0000 ^0|1|1\\.?0{1,4}$; 总结:^...
  • **输出:**从左到右依次输出3个double(均保留2位小数输出,宽度为5),三个格式依次为:右侧填充空格,左侧填充空格,直接输出 输入int,然后输入3个整数(以1个或多个空格分隔)。**输出:**将3个整数相加后输出。 ...
  • 1、题目: 题目描述 数列的第项为n,以后各项为前项的...对于每组输入数据,输出该数列的和,每个测试实例占行,要求精度保留2位小数。 示例1 输入 81 4 2 2 输出 94.73 3.41

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,776
精华内容 7,510
关键字:

java输入数据保留1位小数

java 订阅