在正式学习前,我们需要像学习C、C++一样看一下Hello World的代码
public class Hello{
public static void main (string[] args) {
system. out.print ( "Hello, world ! " ) ;
}
}
这可以帮助我们理解Java中的代码
目录
一、注释
平时我们编写代码,在代码量比较少的时候,我们还可以看懂自己写的,但是当项目结构一旦复杂起来,我们就需要用到注释了。注释并不会被执行,是给我们写代码的人看的书写。注释是一个非常好的习惯。在Java中,分别有以下三种注释:
1.单行注释
以双斜杠“//”标识,只能注释一行内容,用在注释信息内容少的地方。打开 IDEA,在 Java 代码中使用单行注释,以“HelloWorld"程序为例
public class HelloWorld {
public static void main(String[] args) {
//单行注释
//输出HelloWorld
System.out.println("HelloWorld");
}
}
2.多行注释
包含在“/*”和“*/”之间,能注释很多行的内容。为了可读性比较好,一般首行和尾行不写注释信息,以“HelloWorld"程序为例
public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
/*
多行注释
无论多少行
在多行注释符号内
都为注释内容
*/
}
}
注意:多行注释可以嵌套单行注释,但是不能嵌套多行注释和文档注释。
3.文档注释
包含在“/**”和“*/”之间,也能注释多行内容,一般用在类、方法和变量上面,用来描述其作用。注释后,鼠标放在类和变量上面会自动显示出我们注释的内容。目前处于新手学习阶段,使用较少,优先熟练使用单行注释和多行注释。
我们也以”HelloWorld"为例
public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
//JavaDoc:文档注释
/**
* @Description HelloWorld
*/
}
}
二、标识符与关键字
关键字
Java关键字是一个保留字,具有与之相关的特殊含义。为了便于识别,它们通常用Java突出显示。
关键字
标识符
标识符(identifier)是指用来标识某个实体的一个符号,在不同的应用环境下有不同的含义。在计算机编程语言中,标识符是用户编程时使用的名字,用于给变量、常量、函数、语句块等命名,以建立起名称与使用之间的关系。标识符通常由字母和数字以及其它字符构成。
在Java中,我们需要注意以下几点:
1.所有的标识符都应该以字母(A-Z或者a-z)、美元符($)、或者下划线(_)开始
2.首字符之后可以是字母(A-Z或者a-z)、美元符($)、或者下划线(_)或数字的任何字符组合
3.不能使用关键字作为变量名或方法名
4.标识符是大小写敏感的
5.可以使用中文命名
合法标识符举例:acg、$money、_value、__1_value
非法标识符举例:123abc、-salary、#abc
中文命名:
String 段位 ="最强王者";
三、数据类型
在开始说明Java的数据类型前,我们需要简述一下强类型语言和弱类型语言。
强类型语言
即强制数据类型定义的语言。也就是说,一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是这个数据类型了。有以下几点需要注意:
1.如果你定义了一个整型变量 a,那么程序根本不可能将 a 当作字符串类型处理。
2.强类型定义语言是类型安全的语言。
3.当你定义一个变量是某个类型,如果不经过代码显式转换(强制转化) 过,它就永远都是这个类型,如果把它当做其他类型来用,就会报错。
错误示范:
String a ;
System.out.println(a);
正确示范:
String a = "lol";
System.out.println(a);
弱类型语言
即数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。你想把这个变量当做什么类型来用,就当做什么类型来用,语言的解析器会自动(隐式)转换。
Java属于强类型语言,它的数据类型共分为两大类:基本类型(primitive type)和引用类型(reference type)
基本数据类型(primitive type)
1)数据类型
1.整数类型
①byte占1个字节范围:-128-127
②short占2个字节范围:-32768-32767
③int占4个字节范围:-2147483648-2147483647
④long占8个字节范围:-9223372036854775808-9223372036854775807
2.浮点类型
⑤float占4个字节
⑥double占8个字节
3.字符类型
⑦char占2个字节
2)boolean类型
⑧占1位其值只有true和false两个
什么是字节
字节(Byte)是计算机信息技术用于计量存储容量的一种计量单位,也表示一些计算机编程语言中的数据类型和语言字符。
位(bit):是计算机内部数储存的最小单位,11001100是一个儿位二进制数。
字节(yte):是计算机中数据处理的基本单位,习惯上用大写B来表示。
1B (byte,字节) = 8bit(位)
字符:是指计算机中使用的字母、数字、字和符号。
1bit表示1位,
1Byte表示一个字节1B=8b
1024B=1KB
1024KB=1M1024M=1G
引用数据类型
1.类
2.接口
3.数组
数据类型扩展
整数拓展:
进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
输出结果为
10
8
16
讨论
float f = 0.1f是否等于double d =1.0/10?
float d1 = 0.1f是否等于float d2 = d1+1?
输入编程:
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);
float d1 = 23131312312312313f;
float d2 = d1 + 1;
System.out.println(d1==d2);
得到结果为
false
true
原因
当我们用浮点类型float表示实数时,它是有限的和离散的,会产生舍入误差。舍入误差是指运算得到的 近似值 和精确值之间的差异,接近但不等于实际结果。使用时最好完全使用浮点数进行比较。
字符拓展:
输入编程:
char c1 = 'a';
char c2 = '中';
System.out.println( c1);
System.out.println( (int)c1);//强制转换
System.out.println(c2);
System.out.println( (int)c2);//强制转换
得到结果为:
a
97
中
20013
原因:所有的字符本质都是数字。在编码Unicode中它只占2个字节并可以表示65536字符,通过这些字符可以转换成其他文字。
char c3 = '\u0061';
输出结果为:
a
转义字符:
\t 制表符
\n 换行
布尔值拓展:
boolean flag = true;
if(flag==true){}
或者
boolean flag = true;
if(flag){}
其中
if(flag==true){}与if(flag){}等价
四、类型转换
由于Java是强类型语言,所以要进行有些运算的时候,需要用到类型转换。运算中不同类型的数据先转化为同一类型,然后进行运算。下面是容量从低到高排序
低 ----------------------------------------------------------高
byte,short,char—> int —>long—>float—>double
注意:float是32位但排在64位的long后面,是因为小数的优先级高于整数
我们输入以下代码:
int a =128;
byte b = (byte)a;
System.out.println(a);
System.out.println(b);
输出结果为:
128
-128
原因:byte内存最大值为127,128超出最大值,内存溢出。
在由高转低时,我们需要强制转换。
格式 (类型)变量名
而由低转高时,编程会自动转换,无需加其他代码。
int a =128;
double b = a;
输出结果为:
128
128.0
若我们输入
System.out.println((int)23.8);
System.out.println((int)-45.36f);
结果为
23
-45
这是因为在前后精度并不一样,需要与int保持一致。
总结:
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候,强制转换
4.转换过程中可能存在内存溢出或者精度问题
常见问题:
1.操作比较大的数的时候,注意溢出问题
int money = 10_0000_0000;
输出结果为:
1000000000
可以发现下划线_并没有被输出。这个特性可以使我们更加方便读出数字。
下面我们看一串代码:
int money = 10_0000_0000;
int years = 20;
int total = money*years;
long total2 = money*years;
long total3 = money*((long)years);
输出total、total2、total3,得到的答案分别为-1474836480、-1474836480、20000000000。
total输出的值为-1474836480是因为计算的时候数值已经溢出,最终得到的答案也自然为-1474836480。而total2为什么输出值也是-1474836480呢?在软件运行的时候,years是int类型,money也是int类型,计算结果是先转换为int类型再转化为long类型,在转化为long类型前已经数据溢出,此时我们将year提前转化为long,则输出数值正确。将money转化为long类型也是可以的。
五、变量
变量指可以变化的量,一般格式为
数据类型 变量名 = 值;
type varName [=value] [{,varName[=value]}];
可以用逗号隔开来声明多个同类型变量
int a,b,c;
int a=1,b=2,c=3;//不建议这么写,建议分开写
String name = "lol";
char x = 'X';
double pi = 3.14;
Java是一种强类型语言,每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。
变量有三种作用域,分别为类变量、实例变量、局部变量。
public class demo06 {
static int allClicks = 0;//类变量
String str = "hello world";//实例变量
public void method(){
int i = 0;//局部变量
}
}
为了更好说明三种变量,我们输入以下代码:
public class demo06 {
//属性:变量
//实例变量:从属于对象;如果不自行初始化,这个类型的默认值
//布尔值:默认值为false
//除了基本类型,其余默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量:必须声明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字 = new demo06();
demo06 Demo06 = new demo06();
System.out.println(Demo06.age);
System.out.println(Demo06.name);
//类变量 static
}
//其他方法
public void add(){
System.out.println(i);//该部分无法输出,因为i是局部变量
}
}
常量(Constant)
常量是初始化(initialize)后不能再改变值,不会变动的值。所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中不允许被改变。
final 变量名 = 值;
final double PI = 3.14;
常量名一般使用大写字符。
我们输入以下代码
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
输出结果为3.14。
注意:修饰符不分先后顺序。
将第一行改写成
final static double PI = 3.14
最终输出结果是不变的。
变量的命名规范
1.所有变量、方法、类名见名知意
2.类成员变量:首字母小写和驼峰原则:monthSalary 除了第一个单词以外,后面的单词首字母大写
3.局部变量:首字母小写和驼峰原则,和类成员变量一样
4.常量:大写字母和下划线:MAX_VALUE
5.类名:首字母大写和驼峰原则:Man,GoodMan
6.方法名:首字母小写和驼峰原则:run(),runRun()
六、运算符
Java语言支持如下运算符
·算术运算符:+,-,*,/,%,++,--
·赋值运算符:=
·关系运算符:>,<,>=,==,!=instanceof
·逻辑运算符:&&,||,!
·位运算符:&,|,^,~,<<,>>,>>>(了解!!!)
·条件运算符: ?:
扩展赋值运算符:-+,-=,*=,/=
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b);
结果为:
false
true
false
true
1
long a = 123165456121L;
int b = 123;
short c = 10;
byte d =8;
System.out.println(a+b+c+d);
System.out.println(b+c+d);
System.out.println(c+d);//int类型
结果为:
123165456262
141
18
int a = 10;
int b = 20;
int c = 21;
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
System.out.println(c%a);
结果为:
false
true
false
true
1
自增自减运算符
自增自减运算符为自增(++)和自减(--)。具体用法可以观察以下代码
int a = 3;
int b = a++;//执行完这行代码后先给b赋值a再自增
System.out.println(a);
int c = ++a;//执行完这行代码前a先自增再赋值给b
System.out.println(a);
System.out.println(b);
System.out.println(c);
输出结果为:
4
5
3
5
幂运算
进行幂运算可使用math
//幂运算 2^3
double pow = Math.pow(2,3);
System.out.println(pow);
输出结果为:
8
逻辑运算符
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a && b));//逻辑与运算:两个变量都为真,结果才为true
System.out.println("a || b:"+(a || b));//逻辑或运算:两个变量有一个为真,结果则为true
System.out.println("!(a && b):"+!(a && b));//如果为真则变为假,如果是假则变为真
位运算符
位运算符主要针对二进制,它包括了:“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符,但逻辑运算符是针对两个关系运算符来进行逻辑运算,而位运算符主要针对两个二进制数的位进行逻辑运算。下面详细介绍每个位运算符。
我们先假设
A=0011 1100
B=0000 1101
1.与运算符
与运算符用符号“&”表示,其使用规律如下:
两个操作数中位都为1,结果才为1,否则结果为0。
A&B=0000 1100
2.或运算符
或运算符用符号“|”表示,其运算规律如下:
两个位只要有一个为1,那么结果就是1,否则就为0。
我们依旧以A、B为例
A/B = 0011 1101
3.非运算符
非运算符用符号“~”表示,其运算规律如下:
如果位为0,结果是1,如果位为1,结果是0。
~B = 1111 0010
4.异或运算符
异或运算符是用符号“^”表示的,其运算规律是:
两个操作数的位中,相同则结果为0,不同则结果为1。
A^B = 0011 0001
5.左移运算符与右移运算符
左移运算符将运算符左边的对象向左移动运算符右边指定的位数。右移运算符是将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制,也就是说,如果值为正,则在高位补0,如果值为负,则在高位补1。
我们输入以下代码:
System.out.println(2<<3);
该行代码表示2在二进制中向左移动三位。为了方便记忆,可以理解为左移是*2,右移是/2
扩展赋值运算符
当使用扩展运算符时,变量在参与赋值运算时会把结果自动强制转换为当前变量的类型。
int a = 10;
int b = 20;
a+=b; //a = a+b
a-=b; //a = a-b
System.out.println(a);
System.out.println(""+a+b);//结果进行拼接
System.out.println(a+b+"");//结果继续计算再拼接
三元运算符
基本语法为
条件表达式?表达式1:表达式2;
x ? y : z
它的含义为如果条件表达式x为true,运算后的结果是表达式y,否则为z
int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type);
输出结果为:
及格
运算符优先级
下表中优先级上行优先于下行
七、包机制
为了更好地组织类,Java提供了包机制,用于区别类名的命名空间。
包机制的语法格式为:
package pk1[. pkg2[. pkg3...] ];
一般利用公司域名倒置作为包名。比如百度就会使用com.baidu.XXX来分包。我采用分包如下图所示:
为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包,使用“import”语句可完成次功能。
import package1[.package2...].(classname|*);
例如以下代码:
package com.xian.base.operator;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) {
Date
我们可以看见import必须在 package com.xian.base.operator下方,否则程序会报错。
如果我们想导入其他包的类,那么我们可以输入
import com.xian.base.Demo01;
此时系统会报错,这是因为Demo01已经被定义过,在以后分包的时候注意包里面的名字不要重复。
八、Java Doc
Javadoc命令是用来生产自己API文档的。
参数信息
- @author作者名
- @version 版本号
- @since 指明需要最早使用的JDK版本
- @param参数名
- @return返回值情况
- @throws异常抛出情况
package com.xian.base;
/**
* @author xian
* @version 1.0
* since 8.0
*/
public class Doc {
String name;
public String test(String name){
return name;
}
}
我们随意定一个变量name,像上面代码输入,在String name下加上
/**
*/
系统会自动生成
/**
*
* @param name
* @return
*/
我们改写一下倒数第四行的代码,抛出一个异常,
public String test(String name) throws Exception{
像上述打出注释符,结果为:
/**
*
* @param name
* @return
* @throws Exception
*/
我们打开Doc的文件夹,用cmd指令调出该文件夹的窗口。
我们输入
java -encoding UTF-8 -charset UTF-8 Doc.java
我们可以看见以下文字
我们返回文件夹可以看见生成若干网页和文件
点击index网页可以进入主页
我们可以看见我们生成的JavaDos文档
如何使用IDEA生产JavaDos文档?
打开菜单栏中tools,点击Generate JavaDoc
注意command line argument一栏中需要填入
-encoding UTF-8 -docencoding UTF8 -charset UTF-8
点击生成键即可生成JavaDoc文档