零基础学Java——小白的Java之路（2）

Java标识符

标识符用来表示变量、方法或类等的名字。

定义的规则如下：

• • 只能包含字母、数字、下划线和美元符号$。
  • 不能以数字开头
  • 严格区分大小写，如 a 和 A 是不同的标识符
  • 没有长度限制

注意：标识符的命名应该有自明性（见名知意），看到名字就可以知道这个标识符表示的内容。

下面是一些合法的标识符（名称）：

myName，My_name，Points，$points,_sys_ta，OK，_23b，_3_

以下是一些非法的标识符：

2thupk，high-dig，Not/ok，#name

使用标识符进行命名的时候，我们会遵循下面的定义风格：

• • 变量名：第一个单词的字母小写，后面每个单词的首字母大写。如person，personName。
  • 方法名：第一个单词首字母小写，后面每个单词的首字母大写。如eat()，showName()。
  • 类名：以大写字母开头。如Home，Hello。
  • 常量：全部大写。如PI，NUMBER。

注意：定义风格与语法没有关系，但是一个优秀的程序员都会按照这个要求规范自己的代码。

关键字和保留字

正确识别Java语言的关键字（keyword）和保留字（reserved word）是十分重要的。

Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。

保留字是java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。

所以我们在等一标识符的时候，不能与它们冲突，否则代码不能正常执行。

目前的保留字：const，goto

关键字如下：

分隔符

空格、圆括号、花括号、分号等。

每条语句无论一行还是多行都以分号结束。

代码块（Block）是包含在{}里面的多条语句，块可以嵌套。

空白由一个或多个空格组成，也可以由一个或多个tab空格组成。

注释

Java支持单行及多行注释，注释中的内容会被编译器忽略。

单行注释：以换行符结束。语法：

//......

多行注释：可同时注释很多内容。语法：

/*......

......*/

文档注释：可使用javadoc工具从源代码和文档注释中将信息取出，转换为HTML文件。语法：

/**
..........
..........
*/

Java数据类型划分

基本数据类型

变量和常量

变量：用于标识数据的存储单元，可用于数据存储和运算。各种类型的变量创建后都有默认值。

变量的定义一般格式如下：

　　　　<数据类型><变量标识符>=<值>;

double x = 3.1415;

变量赋值后可以修改，格式如下：

　　　　<变量标识符>=<值>;

x = 1.2345;

注意：在Java中，所有的变量在使用之前必须声明。

常量有字面量和符号量两种。

字面量表示基本数据类型的源代码，如整型字面量：6

符号常量指用标识符表示的常量。

定义的一般格式如下：

<final><数据类型><符号常量标识符>=<常量值>;

例如：

final double PI = 3.1415926;

final int COUNT=1000;

注意：常量一旦赋值不能修改。

实型数据

实型常量

用十进制数形式表示，由数字和小数点组成，例如：3.25。

用科学计数法形式表示，例如：123E-3。

数后加f或F为float，加d或D为double，没有后缀修饰的则缺省为double类型。

实型变量

实型变量按长度分为：float和double。

双精度浮点型double比单精度浮点型float的精度更高，表示的数据的范围更大。

三个特殊浮点值

正无穷大：Double.POSITIVE_INFINITY

负无穷大：Double.NEGATIVE_INFINITY

非数字：Double.NaN

注意：Double.NaN=Double.NaN的值为true。

字符型数据

字符常量是单引号括起来的一个字符，如：‘J‘、‘*‘。

Java中有以反斜杠（\）开头的字符，反斜杠将其后的字符转变为另外的含义，称为转义字符。

Java中的字符型数据是16位的Unicode字符，汉子和英文字母占的内存空间相同。

"Java你好"共12个字节。

字符变量的定义如下：

char ch=‘c’;

字符串常量数据

字符串常量是使用双引号括起来的字符序列。

例如：

"Let‘s learn Java!";

String str = "Hello world";

字符串变量作为对象来处理，通过String和StringBuffer类的构造方法来定义。

String s = new String();

布尔型数据

布尔型常量值只有：true和false。

布尔型变量为boolean类型，取值为true和false。例如：

boolean b =true;

 示例代码

 1 //java数据类型
 2 public class DataType{
 3     public static void main(String args[]){
 4         //变量是用来存储和操作数据的
 5         //数据类型 变量名称=值
 6         //byte    大小8位
 7         byte a = 1;         //定义一个字节型（byte）变量并赋值为1
 8         a=2;                //变量值可以改变
 9         //a=200             //数值过大
10         System.out.println("a="+a);  //输出变量
11
12         //short   大小16位
13         short b =200;
14         System.out.println("b="+b);
15
16         //int      大小32位
17         int c =21543;
18         //c = 141343141341;     //数值过大
19         System.out.println("c="+c);
20
21         //long     大小63位  最大表示2^63-1
22         long d = 12344444444L;
23         //注意：整型字面量默认是int   表示长整型字面量要在最后加l或者L
24         //d = 1431242342341242;
25         System.out.println("d="+d);
26
27         //float     32位
28         //注意：小数的字面量默认是double，表示float字面量后加f或者F
29         float e = 1.23f;
30         System.out.println("e="+e);
31
32         //double   64位
33         double f = 3.14;
34         System.out.println("f="+f);
35
36         //char    16位（unicode）
37         char aa=‘男‘;      //将字符放在单引号中只能1个字符
38         aa = 10;
39         aa = ‘\u0041‘;
40         //转义字符，用\改变字符的含义，例如\n表示换行，\‘表示单引号等
41         System.out.println("aa="+aa);
42
43         //boolean      1位
44         //布尔值只有true和false两个取值
45         boolean bb=false;
46         System.out.println("bb="+bb);
47
48         //常量 final
49         //常量赋值后不可修改
50         final double PI=3.1415926;
51         //PI=3.14;
52         System.out.println("PI="+PI);
53
54     }
55 }

Java数据类型

类型转换

自动类型转换：低优先级的数据自动会转换为高优先级的数据

byte->short->char->int->long->float->double

强制类型转换：优先级高的数据转换成优先级低的数据。例如：

double d =3.14159d;

int a=(int)d;

如果下列两个条件都满足，那么将一种类型的数据赋给另一种类型变量时，讲执行自动类型转换。

1. 1. 两种类型兼容
   2. 目标数据类型的取值范围比源数据类型的取值范围大

当满足以上两个条件时，自动的“加宽转换”就可以进行。

例如：将一个byte值赋给int类型的变量

byte a =10;
int x =a;

对于加宽转换，数字类型，包括整数和浮点类型都是彼此兼容的，但是数字类型和字符类型或布尔类型是不兼容的。字符类型和布尔类型也是互相不兼容的。

当需要将int型的值赋给一个byte型的变量时该怎么办？

此时，只有采用被称为“变窄转换”的转换方式。因为你肯定要将源数据的值变小才能适合目标数据类型。

在这种情况下，就必须进行强制类型转换。所谓的强制类型转换是一种显示的类型变换方式，其通用格式：(target-type) value

其中，目标类型(target-type)制定了要将指定值所转换成的类型。

例如，下面的程序段将int型强行转换成byte型。

int a;
byte  b;
b = (byte)a;

当把一个浮点值赋给整数类型时，将发生一种不同的类型转换：截断

即当把浮点值赋给整数类型时，它的小数部分将被舍去。

例如，如果将值1.23赋给一个整数，其结果只是1,0.23被舍弃。

当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为目标类型值域取模而减少。

下面的这个程序说明了强制类型转换过程。

public class Conversion {

	public static void main(String args[]){

		byte b;

		int i = 258;

		double d = 338.136;

		System.out.println(“\n将int类型数据转换为byte");

		b = (byte) i;

		System.out.println("i and b: " + i + “, " + b);

		System.out.println(“\n将double类型数据转换为int");
		i = (int) d;

		System.out.println("d and i :" + d + " ," + i);

		System.out.println(“\n将double类型数据转换为byte");

		b = (byte) d;

		System.out.println("d and b: " + d + “, " + b);
	}
}

运行结果如下：

将int类型数据转换为byte

i and b: 258, 2

将double类型数据转换为int

d andi: 338.136 ,338

将double类型数据转换为byte

d and b :338.136, 82

下面让我们分析一下每个类型转换。

当值258被强制转换为byte变量时，取值它的低八位；

当把变量d转换为int型，它的小数部分被舍弃了；

当把变量d转换为byte型，它的小数部分被舍弃了，也是取它的低八位。

 示例代码

 1 //类型转换
 2 public class TypeConvert{
 3     public static void main(String args[]){
 4         //1.自动类型转换
 5         //低优先级数据类型自动转换成高精度的数据类型
 6         //byte->short->char->int->long->float->double
 7
 8         byte b=1;
 9         short s=b;
10         System.out.println("s="+s);
11
12         double d=b;
13         System.out.println("d="+d);
14
15         //2.强制转换
16         //强制转换可能会导致数据的丢失
17         //格式  （目标数据类型）值
18         float f=1.23F;
19         int i =(int)f;               //小数转整数会直接将小数点后的数字直接舍去，不进行四舍五入
20         System.out.println("i="+i);
21
22         int x=250;
23         System.out.println("x="+x);
24         byte y =(byte)x;              //取int的低8位存入byte，第8位是符号位
25         System.out.println("y="+y);
26     }
27 }

类型转换

赋值运算符

包括：=，+=，-=，*=，/=，%=

int a=2;

a =a*b;

a*=b;

a%b=b;

a =a%b;

算术运算符

包括：+，-，*，/，%，++，--等

后缀++（--）：变量首先进行操作再自身进行加减。

int a=2;

int b =a++;

//a=3,b=2

前缀++（--）：变量首先加减后再进行操作。

int a=2;

int b=++a;

//a=3,b=3

关系运算符

包括：==，！=，<，<=，>，>=

完成操作数的比较运算，结果为布尔类型值。

int a=10;

int b=3;

boolean f=a>b;

//比较a和b的值，结果为true，即f的值为true

逻辑运算符

包括：&，|，!，^，&&，||

注意区别:＆既是位运算符也是逻辑运算符，＆＆只是逻辑运算符，＆与＆＆同时作为逻辑运算符时＆＆是短路的(截断功能)，而＆并不短路。 

int a=6;

int b=8;

int c=10;

int d=12;

boolean x=++a>b++&&c++>d--;

//上面代码的结果：
//a=7   b=9  c=10  d=12   x=flase

条件运算符

也称作三目运算符

一般形式为：

<表达式1>?<表达式2>:<表达式3>;

表达式1的数据类型为布尔值类型，如果为true，取表达式2的值为最终结果，否则取表达式3的值。

int x=2 ;i

nt y=3;

int salary=(x ==y)?2000:200;

//上面代码中因为x==y不成立，所以salary的最终值为200。

位运算符

• • 按位取反?，?01010101=10101010。 (1变0 0变1)
  • 按位与&，11111001&10001111=10001001。 (同为1时为1 )
  • 按位或|，11111001|10001111=11111111。 （只要有一个为1就为1）
  • 按位异或^，11111001^10001111=01110110。 （相同为0 不同为1）
  • 左移<<，10101011<<2=10101100。
  • 带符号右移>>，10101011>>2=11101010。
  • 无符号右移>>>

 示例代码

 1 //运算符
 2 public class Operator{
 3     public static void main(String args[]){
 4         //1.算数运算符：+ — * / % ++ --
 5         /*int a =1;
 6         int b =2;
 7         int c =a/b;           //两个整数相除结果仍为整数
 8         System.out.println("c="+c);
 9
10         //++自增
11         int i =1;
12         //i++;          //后缀自增
13         //++i;          //前缀自增
14         int i2=i++;      //先其他操作后自加
15         System.out.println("i2="+i2+",i="+i);
16         int i3=++i;      //先自加后其他操作
17         System.out.println("i3="+i3+",i="+i);
18         */
19
20         //2.赋值运算符：= += -= *= /= %=
21         /*int a =2;
22         int b=3;
23         a+=b;   //相当于a=a+b
24         System.out.println("a="+a);
25         */
26
27         //3.关系运算符：== != > < >= <=
28         //关系运算符结果是布尔类型
29         /*int a =2;
30         int b =3;
31         boolean bl = a<b;
32         System.out.println("bl="+bl);
33         */
34
35         //4.逻辑运算符
36         //专门针对布尔类型数据进行运算
37         //与 & && 两个同时为true，结果才为true
38         //或| ||  只要有一个为true，结果就为true
39         //取反 !
40         //异或 ^   两个相同结果为false，不同为true
41
42         /*boolean b1 = true;
43         boolean b2 = false;
44         boolean b3 = b1^b2;
45         System.out.println("b3="+b3);
46         */
47
48         //具有短路功能的与 && 或 || 在运算过程中已知结果便不再进行后面的运算
49
50         /*int a=2,b=4,c=10,d=11;
51         boolean c1 = ++a >= b-- && c-- ==--d;
52         System.out.println("a="+a+",b="+b+",c="+c+",d="+d+",c1="+c1);
53         */
54
55         //5.条件运算符（三目运算符）
56         /*
57             条件?表达式1:表达式2
58             注意表达式1和表达式2 类型相同
59             如果条件为true 取表达式1的结果，否则取表达式2的结果
60         */
61         /*int a=2;
62         int b=3;
63         int c = a>b?a:b;
64         System.out.println("c="+c);
65         */
66
67         //6.位运算符
68         //按位与 &
69         //按位或 |
70         //按位取反 ~
71         //异或 ^
72         int a =2;   //0...0 0010
73         int b =3;   //0...0 0011
74         int c =a&b;    //0010
75         System.out.println("c="+c);
76
77         //位移
78         //<<左移
79         int d =2; //0...0 0010
80         d =d<<2;
81         System.out.println("d="+d);
82         //右移>>
83         int e =-2; //1...1 1110
84         e =e>>2;   //111...1 1111  -1
85         System.out.println("e="+e);
86         //无符号右移>>>
87         int f = -2;
88         f = f>>>2;
89         System.out.println("f="+f);
90     }
91 }

运算符

表达式

由操作数和运算符按照一定的语法格式组成表达式。

(a+b)*(c--d)

变量的作用域

• • 所谓的作用域就是在变量在什么时候是可见在什么是不可见的！
  • 作用域决定变量“可见性”与“存在时间”
  • 作用域的范围：只作用于从声明开始到所在的{}结束。

 示例代码

 1 //变量的作用域指的是变量从定义开始到所在的花括号}结束
 2 public class Scope{
 3     public static void main(String args[]){
 4         int x =10;
 5         {
 6             System.out.println("x="+x);
 7             double y =1.23;
 8         }
 9         //System.out.println(y);  //超出了y的作用域
10     }
11 }

作用域

简单的输入输出

输出：

使用System.out对象进行输出。

println()：输出文本并换行

print()：输出文本不换行

如：System.out.println(“hello world!”);

输入：

1、使用Scanner对象输入。

new Scanner(System.in)

import java.util.Scanner与next()或nextInt()方法

2、使用命令行参数main()方法的args[]。

 示例代码

 1 //简单的输入输出
 2 import java.util.Scanner;  //引入Scanner类
 3 public class InOut{
 4     public static void main(String args[]){
 5         //输入1：通过main方法的args参数
 6         /*String str =args[0];
 7         int a = Integer.parseInt(str);   //将字符串转换成整数
 8         System.out.println("a*10="+a*10);
 9         */
10
11         //输入2：通过Scanner对象（扫描器）
12         //使用new 创建Scanner对象
13         Scanner scan = new Scanner(System.in);   //System.in表示从控制台读取数据
14         //调用功能next()，nextInt(),nextDouble(),nextLine()
15         System.out.print("请输入一个整数：");
16         int i = scan.nextInt();
17         System.out.println("你输入的是:"+i);
18
19         //输入文本
20         System.out.print("请输入一句话：");
21         Scanner myscan = new Scanner(System.in);
22         String a =myscan.nextLine();
23         System.out.println("你输入的是："+a);
24     }
25 }

简单的输入输出

练习

从屏幕上输入两个实数，计算他们的和，差，积，然后输出

 1 //从屏幕上输入两个实数，计算他们的和，差，积，然后输出
 2
 3 import java.util.Scanner;
 4 public class HWD1T1{
 5     public static void main(String args[]){
 6         /*
 7         Scanner a =new Scanner(System.in);
 8         System.out.print("请输入第一个数字：");
 9         double x = a.nextDouble();
10
11         Scanner b =new Scanner(System.in);
12         System.out.print("请输入第二个数字：");
13         double y = b.nextDouble();
14         */
15
16         /*
17         String str1 = args[0];
18         String str2 = args[1];
19         double x = Double.parseDouble(str1);
20         double y = Double.parseDouble(str2);
21         */
22
23         double x =Double.valueOf(args[0]).doubleValue();
24         double y =Double.valueOf(args[1]).doubleValue();
25
26         double sum=x+y;
27         double diff=x-y;
28         double avg=x*y;
29
30         System.out.println("它们的和是"+sum);
31         System.out.println("它们的差是"+diff);
32         System.out.println("它们的积是"+avg);
33     }
34 }

第一题

用户从屏幕上输入圆的半径，然后计算并输出该圆的直径、周长和面积。
注意：∏的值可以使用预定义常量Math.PI。该常量要比3.14159精确。

 1 //用户从屏幕上输入圆的半径，然后计算并输出该圆的直径、周长和面积。
 2 //注意：∏的值可以使用预定义常量Math.PI。该常量要比3.14159精确。
 3 import java.util.Scanner;
 4 public class HWD1T2{
 5     public static void main(String args[]){
 6         Scanner scan = new Scanner(System.in);
 7         System.out.print("请输入圆的半径：");
 8         double r = scan.nextDouble();
 9
10         double d = r*2;
11         double C = Math.PI*r*2;
12         double S = Math.PI*r*r;
13
14         System.out.println("该圆的直径为"+d);
15         System.out.println("该圆的周长为"+C);
16         System.out.println("该圆的面积为"+S);
17     }
18 }

第二题

编写一个应用程序，读取用户输入的一个整数，判断该整数的奇偶性，并将结果显示在控制台上。

 1 //编写一个应用程序，读取用户输入的一个整数，判断该整数的奇偶性，并将结果显示在控制台上。
 2 //提示：使用求模和三目运算符。
 3 import java.util.Scanner;
 4 public class HWD1T3{
 5     public static void main(String args[]){
 6         Scanner scan =new Scanner(System.in);
 7         System.out.print("请输入一个整数：");
 8         int a = scan.nextInt();
 9         String b = a%2==0?"偶数":"奇数";
10         System.out.println("该数字是："+b);
11     }
12 }
13 　　

第三题

编写一个程序，输入一个5位数，将输入数分离成单个数字，然后打印出这些数字，个数字间间隔3个*符号。

 1 //编写一个程序，输入一个5位数，将输入数分离成单个数字，然后打印出这些数字，个数字间间隔3个*符号。
 2 //提示：使用整除除法和求模运算符。
 3 //例如：如果用户输入：42933,那么输出是：4***2***9***3***3
 4
 5 import java.util.Scanner;
 6 public class HWD1T4{
 7     public static void main(String args[]){
 8         Scanner scan = new Scanner(System.in);
 9         System.out.print("请输入一个5位数：");
10         int a = scan.nextInt();
11
12         int s5=a/10000;
13         int s4=(a/1000)%10;
14         int s3=(a/100)%10;
15         int s2=(a/10)%10;
16         int s1=a%10;
17
18         System.out.println(s5+"***"+s4+"***"+s3+"***"+s2+"***"+s1);
19     }
20 }
21 　　

第四题

编写一个Java应用程序,用户从键盘输入一个浮点数据,将该浮点数保留两位小数位后输出。

 1 //编写一个Java应用程序,用户从键盘输入一个浮点数据,将该浮点数保留两位小数位后输出。
 2 import java.util.Scanner;
 3 public class HWD1T5{
 4     public static void main(String args[]){
 5         Scanner scan =new Scanner(System.in);
 6         System.out.print("请输入一个小数：");
 7         double a = scan.nextDouble();
 8
 9         //int b =(int)(a*100);
10         //a=(double)b/100;
11         //System.out.println(a);
12
13         System.out.println(String.format("%.2f",a));
14     }
15 }
16 　　

第五题

输入一个数，如果能被3、4、5中的任意一个数整除，则输出：　i+“能被3或者4或者5整除” （i是输入的数字）。

 1 //输入一个数，如果能被3、4、5中的任意一个数整除，则输出：　i+“能被3或者4或者5整除” （i是输入的数字）。
 2 //用||实现。
 3 import java.util.Scanner;
 4 public class HWD1E1{
 5     public static void main(String args[]){
 6         Scanner scan = new Scanner(System.in);
 7         System.out.print("请输入一个整数：");
 8         int a = scan.nextInt();
 9         String b=a%3==0||a%4==0||a%5==0?"能被3或4或5整除":"不能被3或4或5整除";
10         System.out.println(a+b);
11     }
12 }
13 　　

第六题

输入一个数，如果是能被2整除，且能被3整除，则输出：i+”能被2和3整除” （i是输入的数字）。

 1 //输入一个数，如果是能被2整除，且能被3整除，则输出：i+”能被2和3整除” （i是输入的数字）。
 2 //用&&实现。
 3 import java.util.Scanner;
 4 public class HWD1E2{
 5     public static void main(String args[]){
 6         Scanner scan =new Scanner(System.in);
 7         System.out.print("请输入一个整数：");
 8         int a = scan.nextInt();
 9         String b =a%2==0&&a%3==0?"能被2和3整除":"不能被2和3整除";
10         System.out.println(a+b);
11     }
12 }
13 　　

第七题

原文地址：https://www.cnblogs.com/xiaomiesang/p/8542550.html