概述
1.注释 : 源代码
作用：使部分内容只为程序员可见，不为编译器所编译、虚拟机所执行
位置：类声明前后、方法声明前后、属性声明前后、方法体中。几乎可以在一个源文件任意位置，但不能在一个关键字字符中插入注释
类型:
1) 单行注释：
//text ——从 // 到本行结束的所有字符均作为注释而被编译器忽略(反编译)
2) 多行注释：
/text/ ——从 /* 到 / 间的所有字符会被编译器忽略
3) 文档注释：
/test/ ——从"/*“到”/"间的所有字符会被编译器忽略。当这类注释出现在任何声明(如类的声明、类的成员变量的声明或者类的成员方法的声明)之前时，会作为JavaDoc文档的内容；
@author 类的作者
@version 类的版本
@since 从什么时候开始使用的
@see 另外参照…
@param 方法的参数
@return 方法的返回类型
@exception 方法抛出的异常
例如:
package com.briup.ch02;
/**
* this is my CommentTest Class
* @author briup
* @version 1.0
* @since JDK1.7
* */
public class CommentTest{
//表示这个人的名字
private String name;
/**
*this is a age of person
*
* */
private int age;
/**
* @param name :a name of person
* @exception null
* */
public void setName(String name){
this.name = name;
}
/**
* @return 没有返回类型
* */
public String getName(){
return this.name;
}
public static void main(String[] args){
/*
CommentTest ct = new CommentTest();
ct.setName("tom");
String temp = ct.getName();
System.out.println(temp);
*/
}
}
使用javadoc进行编译：
javadoc -d doc src/CommentTest.java
如果想显示出author和version
javadoc -d doc -author -version src/CommentTest.java
或者:
javadoc -d doc -author -version src/*.java
2.标示符
类、方法和变量的名字
1) 由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字
2) 不能是java中的关键字
3) 大小写敏感 cd CD test Test
4) 没有长度限制。
注:java中标示符是可以使用中文的,但是一般不推荐这样做。
举例:合法标识符 非法标识符
try1 try#
GROUP_7 7GROUP
openDoor open-door
boolean1 boolean
_int int
$int int
推荐常见的标示符命名规则
1) 类名以大写字母开头；
Hello Person Teacher TypeTest
2) 接口名以大写字母开头；
Eat Fly
3) 方法名以小写字母开头；
say go doSomething main println
4) 变量名以小写字母开头；(驼峰命名法)
name age myName myAge num a b c
5) 常量名全部大写，多个单词以"_"连接；
FILE_TYPE PERSON_TITLE
分号、代码块和空格
1)每个语句短语以分号(;)结束 输入 语句 ;
类的声明最后不需要加;
public class Hello{ .... }
方法的声明最后不需要加;
public class Hello{
public void go(){....}
}
属性的声明最后一定要加;
public class Hello{
int id;
private String name;
public int age;
public void go(){....}
}
2)代码片段用{}括起来
常见的有：
类的声明后加{}
方法的声明后加{}
if(){} while(){}
注意:代码的{}后面都不需要加;
3)空白处
空格、tab键、新行和回车等是无关紧不影响代码执行的。
代码的格式 方便阅读代码。
3.关键字
Java语言的关键字是程序代码中的特殊字符。包括：
类和接口的声明——class, extends, implements, interface
包引入和包声明——import, package
数据类型——boolean, byte, char, double, float, int, long, short
某些数据类型的可选值——false, true, null
流程控制——break, case, continue, default, do, else, for, if, return, switch, while
异常处理——catch, finally, throw, throws, try
修饰符——abstract, final, native, private, protected, public, static, synchronized, transient, volatile
操作符——instanceof
创建对象——new
引用——this, super
方法返回类型——void
Java语言的保留字是指预留的关键字，它们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字: goto const
所有关键字都是小写,并且程序中标识符不能以关键字命名；
4.基本数据类型
Java语言中的数据类型分为基本类型和引用类型
基本类型:float double byte short int long char boolean
引用类型:类类型 接口类型 数组类型
数据类型本身是描述程序中数据所具备的特点的,同时数据类型也可以用来定义变量,而变量又是用来接收和存储数据的。
所以java中的变量也只有俩大种类:基本类型变量和引用类型变量
int a = 5;
a=4
String[] args ;
变量代表一段可操作的内存。可以通过操作变量名访问对应的内存。数据类型确定了内存的大小。不同的数据类型占用不同的存储空间。
计算机中:
1字节=8位 0000 0001
基本数据类型又可以分为:整型 浮点类型 布尔类型 字符类型
整型
byte 8位 1字节
short 16位 2字节
int 32位 4字节
long 64位 8字节
浮点类型
float 32位 4字节
double 64位 8字节
布尔类型
boolean 8位 1字节
字符类型
char 16位 2字节
注意:java中采用unicode编码,用俩个字节表示一个字符,但是在其他字符编码中可能不是使用俩个字节表示一个字符
4.1 boolean
boolean类型数据的值为true或者false,在JVM中会转换为1或者0
注意:0代表的是false 1代表的是true
例如:
boolean flag = ture;
boolean bool = false;
(逻辑判断 if )
4.2 char
char是字符,String是字符串
String是类类型,而char是基本数据类型
一个String是由0个或者n个char组成的
1)字符编码
Java语言对文本字符采用Unicode编码。由于计算机内存只能存取二进制数据，因此必须为各个字符进行编码。
例如:a --编码-->0000 0000 0110 0001
2)常见的字符编码包括：
a.ASCII
ASCII--Amecian Standard Code for Information Interchange(美国信息交换标准代码). 主用于表达现代英语和其他西欧语言中的字符。它是现今最通用的单字节编码系统，它只用一个字节的7位，一共表示128个字符。
b.ISO-8859-1
又称为Latin-1, 是国际标准化组织(ISO)为西欧语言中的字符制定的编码，用一个字节(8位)来为字符编码，与ASCII字符编码兼容。所谓兼容，是指对于相同的字符，它的ASCII字符编码和ISO-8859-1字符编码相同。
c.GB2312 中 ----->010101
它包括对简体中文字符的编码，一共收录了7445个字符(6763个汉字+682个其他字符). 它与ASCII字符编码兼容。
d.GBK
对GB2312字符编码的扩展，收录了21886个字符(21003个字符+其它字符), 它与GB2312字符编码兼容。
e.Unicode：万国码 统一码
由国际Unicode协会编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
UCS(Universal Character Set)是指采用Unicode字符编码的通用字符集。
Unicode具有两种编码方案：
用2个字节(16位)编码，被称为UCS-2, Java语言采用;
用4个字节(32位)编码，被称为UCS-4;
f. UTF 可变长度编码
有些操作系统不完全支持16位或32位的Unicode编码，UTF(UCS Transformation Format)字符编码能够把Unicode编码转换为操作系统支持的编码，常见的UTF字符编码包括UTF-8, UTF-7和UTF-16.
Unicode是一个符号集，可以表示很多符号。
utf-8 是Unicode的实现方式之一。是互联网上使用最广泛Unicode的实现方式。
3)字符编码表
每一种字符编码都有一个与之字符编码表,例如在Unicode编码表中十六进制的数字6136对应的汉字是愶
例如:
char c = 'u6136';
System.out.println(c);
4)char值的形式
Java语言采用Unicode编码，字符占2个字节。
字符a
二进制数据形式为 0000 0000 0110 0001
十六进制数据形式为 0x0061
十进制数据形式为 97
char c = 'a';
//设定"a"的十六进制数据的Unicode编码
char c = 'u0061';
//设定"a"的十六进制数据的Unicode编码
//0x开头的数字位十六进制
char c = 0x0061;
//设定"a"的十进制数据的Unicode编码
char c = 97;
//设定"a"的八进制数据的Unicode编码
//0开头的数字为八进制
char c = 0141;
注意:一个中文汉字就是一个字符
char c = '中';
5)转义字符
Java编程人员在给字符变量赋值时，通常直接从键盘输入特定的字符，而不会使用Unicode字符编码，因为很难记住各种字符的Unicode字符编码值。
对于有些特殊字符，比如单引号，如不知道它的Unicode字符编码，直接从键盘输入编译错误：
//编译出错
char c = ''';
为了解决这个问题，可采用转义字符来表示单引号和其他特殊字符：
char c = ''';
char c = '\';
转义字符以反斜杠开头，常用转义字符：
n 换行符，将光标定位到下一行的开头
r 回车,把光标移动到行首(和环境有关 linux环境下 回到行首 覆盖当前行以前的输出内容)
t 垂直制表符，将光标移到下一个制表符的位置
\ 反斜杠字符
' 单引号字符
" 双引号字符
6)空字符串和u0000
键盘上任何一个按键都是一个字符,例如回车键、空格键、Esc键、Shift键等等
//空格字符
char c1 = ' ';
//字符串s1包含了一个空格字符
String s1 = " ";
//字符串s2不包含任何字符,即空字符串(不是null)
String s2 = "";
//这样表示是错误的
//没有空字符
char c2 = '';
//这俩个值是一样的,是char类型的默认值
//只是会占一个字符的位置
char c3 = 0;
char c4 = u0000;
4.2 整数类型
byte, short, int和long都是整数类型，并且都是有符号整数(正负)。与有符号整数对应的是无符号整数，两者的区别在于把二进制数转换为十进制整数的方式不一样。
1：0000 0001
-1：原码 反码 补码
取值范围： 存储机制 +-数
有符号整数把二进制数的首位作为符号数，当首位是0时，对应十进制的正整数，当首位是1时，对应十进制的负整数。对于一个字节(byte)的二进制数, 它对应的十进制数的取值范围是-128~127
无符号整数把二进制数的所有位转换为正整数。对于一个字节(byte)的二进制数, 它对应的十进制数的取值范围是0~255
在Java语言中，为了区分不同进制的数据，八进制数以“0”开头，十六制以“0x”开头,JDK1.7还支持了二进制的直接表示,0b开头
例如:
byte b1 = 97; 十进制
byte b2 = 0141; 八进制
byte b3 = 0x61; 十六进制
byte b4 = 0b01100001; 二进制
//都是97打印出来
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
整数类型的默认类型是int,对于给出一个字面值是99的数据,在没有指明这个数据是什么具体的类型的情况下,那么java默认认为是int类型。
例如:
byte b
short c
int a = b+c;
//编译报错
//a+1中a是byte类型,字面值1没有声明类型,那么默认是int
//byte是8位,int是32位,那么结果是32位的数字
//b只是一个byte类型的变量,那么只能接收8位的数字
//修改为int b = a+1;就可以编译通过
byte a = 1;
byte b = a+1;
//编译通过
//虽然1+1中的1都是默认的int类型
//但是这个俩个1都是固定的字面值
//编译器可以判断出其结果是否超出了byte表示的范围
//上面例子中a+1不能判断出结果的原因是:
//a是变量,是有可能发生变化的
byte c = 1+1;
//编译报错
//编译器判断出其结果超出了byte的表示范围(-128~127)
byte d = 1+127;
//编译报错
//原因:32位的数据赋值给byte类型的变量
//因为使用的1这些都是字面值,默认是int
//所以它默认是在前面补了24个0
byte e = 0b11111111;
//编译通过
//输出结果为255
//因为1的前面补了24个0
int e = 0b11111111;
//编译通过
//输出结果为-1
byte f = (byte)0b11111111;
四种整型类型的声明
byte a1 = 1; (内存中占8位) 1字节
short a2 = 1; (内存中占16位)2字节
int a3 = 1; (内存中占32位)4字节
long a4 = 1L; (内存中占64位)8字节
使用long类型数据的时候后面要加大写L或者小写l,建议加上大写的L,因为小写的l和数字1很像似。
四种整型类型的表示范围
为什么是这个取值范围？
byte 8位 范围:负2的7次方~2的7次方减1
short 16位 范围:负2的15次方~2的15次方减1
int 32位 范围:负2的31次方~2的31次方减1
long 64位 范围:负2的63次方~2的63次方减1
4.3 浮点型 double 1.1 != 1.1
float和double都是java中的浮点型,浮点型可以用来表示小数.
float是32位, 1符号位+8指数位+23尾数位
double是64位,1符号位+11指数位+52尾数位
float和double的精度是由尾数的位数来决定的。浮点数在内存中是按科学计数法来存储的.
float的精度为7位左右有效数字
double的精度为16位左右有效数字
俩种浮点型数据的声明
//后面加f或者F
float f = 10.5f;
//后面加d或者D
double d = 10.5d;
10.5
浮点型的二进制形式
参考样例:
float f = 10.5f;
int b = Float.floatToIntBits(f);
System.out.println(Integer.toBinaryString(b));
浮点型的默认类型是double,对于给出一个字面值是10.8的数据,在没有指明这个数据是什么具体的类型的情况下,那么java默认认为是double类型。
例如:
//编译通过
//字面值1.5默认类型是double
double d = 1.5;
//编译报错
//字面值1.5默认类型是double
//double和float的精确度不一样
float f = 1.5;
//f2编译通过,因为字面值1的类型是int
//f3编译报错,因为字面值1.5的类型是double
float f1 = 10.5f;
float f2 = f1+1;
float f3 = f1+1.5;
浮点型的精度丢失
例如:
System.out.println(1.0-0.66);
输出结果:
0.33999999999999997
Java中的简单浮点数类型float和double不能够进行精确运算，因为大多数情况下是正常的，但是偶尔会出现如上所示的问题。这个问题其实不是JAVA的bug，因为计算机本身是二进制的，而浮点数实际上只是个近似值，所以从二进制转化为十进制浮点数时，精度容易丢失，导致精度下降。
0.8 0.7999999
要保证精度就要使用BigDecimal类，而且不能直接从double直接转BigDecimal,要将double转string再转BigDecimal。也就是不能使用BigDecimal(double val)方法,而是需要使BigDecimal(String val)方法。
例如:
BigDecimal d1 = new BigDecimal(“1.0”);
BigDecimal d2 = new BigDecimal(“0.66”);
double result = d1.subtract(d2).doubleValue();
System.out.println(result);
输出结果:0.34
5.变量的声明和赋值
java中的任意类型可以用来声明变量,包括八个基本类型和三个引用类型
//变量的声明
int x;
//声明多个类型相同的变量
int x,y;
相当于
int x;
int y;
//先声明变量
//再给变量赋值
int x;
x = 10;
//声明变量的同时就赋值
int x = 10;
思考:变量在程序中的作用是什么?
6.理解对象
java是面向对象的编程语言(OOP),面向对象的开发方法把软件系统看成各种对象的集合,这种方式也是接近人的自然思维方式。
世界上万事万物实在太多了,不能一概而论,所以要解决一个问题,必须是要把事物限定到一定的范围之内,那么这个范围就是我们要解决问题的问题域。
例如:我们要给"希望中学"开发一套教师管理系统,那么我们要把这个系统的分析与设计限定在"希望中学"的具体教师管理的规则之中,而不是针对全世界所有中学的教师管理规则。
对象是对问题领域中事物的抽象。对象具有以下特性：
1) 万物皆为对象。问题领域中的实体和概念都可以抽象为对象。例如学生，成绩单、教师、课和教室。
2) 每个对象都是惟一的。正如世界上不存在一模一样的树叶。
3) 对象具有属性和行为。
例如:
小张，性别女，年龄22，身高1.6m, 体重40kg, 能够学习，唱歌。
小张的属性包括姓名、性别、年龄、身高和体重
小张的行为包括学习、唱歌。
4) 对象具有状态。状态是指对象在某个时刻的属性取值。对象的某些行为会改变对象自身的状态。
例如:
小张本来体重为40kg，经为减肥后，体重减到35kg.
肥胖状态: 40kg
|
| 减肥行为
|
肥胖状态: 35kg
5) 每个对象都是某个类的实例
例如:
小张和小王都属于学生类的实例
中国和美国都属于国家类的实例
中文和英文都属于语言类的实例
类是具有相同属性和行为的对象的集合。
同一个类的所有实例(对象)都有相同属性名，但属性的取值不一定相同，例如:
小张和小王都属于学生类，都有姓名、性别、年龄、身高和体重这些属性，但是他们的这些属性取值都可能不同。
同一个类的所有实例(对象)都有相同行为，意味着它们具有一些相同的功能。
例如:
小张和小王都属于学生类,他们都能学习以及能唱歌
6) java中的对象其实就是堆区中的一块内存空间
JVM管理的内存,被划分为了若干区域,其中有一个被称之为堆区,java运行过程产生的所有对象几乎都会在堆区中.垃圾回收器(gc)的工作主要也就是把堆区中把不再被使用的内存(也就是对象)进行回收。
new关键字就是向JVM申请内存空间以便接下来创建对象,这块内存地址就是所创建对象的内存地址,通过该地址也是在内存中找到该对象的唯一方式。
7.定义类
1)分析学生都具备哪些特点以及行为
学生都有学号、姓名、性别
学生都可以说话、学习、跑步
2)把学生这一群体抽象为一个java类:Student
所以一个java类是对某一类事物的整体描述
Student类是对整体学生的描述
3)把学生的"特点"抽象为Student类中的"属性"
所以只要是属于这个Student类的对象都具有这些属性
4)把学生的"行为"抽象为Student类中的"方法"
所以只要是属于这个Student类的对象都具有这些方法
5)如果有需要,可以在类中添加对应的构造器,以便我们在创建对象的时候给对象的属性赋值,如果不添加构造器那么JVM会自动帮我们在类中添加一个无参构造器
定义一个学生类:Student
public class Student{
//属性
public long id;
public String name;
public char gender;
//方法
public void say(){
System.out.println("I can say..");
}
public void study(){
System.out.println("I can study..");
}
public void run(){
System.out.println("I can run..");
}
//无参构造器 创建对象的时候使用
public Student(){}
//有参构造器 创建对象的时候使用
public Student(long id,String name,char gender){
this.id = id;
this.name = name;
this.gender = gender;
}
}
8.创建类的实例
在java代码中,需要把类进行实例化得到该类的对象后,再使用对象去访问对象中的属性以及调用到对象中的方法
形式:
对象.对象中的属性
对象.对象中的方法()
对象.对象中的方法(参数)
注1:首先要使用类进行实例化创建出这个对象
注2:对象调用方法时一定有小括号,对象访问属性时一定没有小括号
类中的属性和方法一般情况是不能直接使用的,类中的代码只是提供了一个创建对象的模板,根据这个模板创建出的对象才可以使用。
所以类只是创建对象的模板,对象才是调用方法、执行代码、完成功能这个过程中的关键点。
注意:类A中有什么属性和方法,那么该类的对象中就有什么属性和方法,因为该对象是根据类A这个模板创建出来的.
根据上面所编写的Student类,进行类的实例化,也就是创建对象。
1)使用 new+类中构造器 的形式创建出该类的对象
new Student();
或者
new Student(1L,"tom",'男');
这种方式可以直接给对象中属性赋值
2)为了方便进一步使用这个对象,需要使用变量去接收这个对象
Student s = new Student();
java是强类型编程语言,数据是什么类型的,那么接收数据的变量类型也要与之对应
3)接下来可以使用对象访问其属性,也可以调用其方法
Student s = new Student();
//对象访问其属性并且给该属性赋值
s.id = 2L;
s.name = "zhangsan";
s.gender = 'm';
//打印出对象中的属性值
System.out.println("id: "+s.id);
System.out.println("name: "+s.name);
System.out.println("gender: "+s.gender);
//对象调用其方法
s.say();
s.study();
s.run();
9.基本类型变量和引用类型变量的区别
1)基本类型变量指的是使用byte、short、int、long、float、double、boolean、char这八种类型声明出来的变量
2)引用类型变量指的是使用任意一个类、任意一个接口、任意一个数组所声明出来的变量
3)基本类型的数据是一种比较简单的数据,不能包含其他类型的数据,也不能调用任何方法
4)对象是一种比较复杂的数据,可以包含其他类型的数据,也可以调用方法
例如:对象s中包含了其他三个不同类型的数据
Student s = new Student(1L,“tom”,‘男’);
5)基本类型变量接收的只能是一些比较简单的数据(8/16/32/64位)
6)引用类型变量接收的只能是对象
Student s = new Student();
引用类型的变量可以简称为 引用
简称:引用"指向"对象
例如:
//使用x不能访问任何属性也不能调用任何方法
int x = 1;
Student s = new Student();
//使用s可以访问对象中的属性
s.name = "tom";
//也可以调用对象中的方法
s.run();
最后
以上就是傲娇枫叶为你收集整理的Java基础(1)标识符 关键字 类型介绍 如何构建类的全部内容，希望文章能够帮你解决Java基础(1)标识符 关键字 类型介绍 如何构建类所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复