Java的语法基础、对象和类、数据类型。

1、Java语法基础

Java基本概念

  1. 对象:对象是类的一个实例,有状态和行为;
  2. 类:类是一个模板,它描述一类对象的行为和状态;
  3. 方法:方法就是行为,一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的;
  4. 实例变量:每个对象都有独特的实例变量,对象的状态由这些实例变量的值决定。

Java代码规范

  1. 大小写敏感:Java 是大小写敏感的,这就意味着标识符 Hello 与 hello 是不同的。
  2. 类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如MyFirstJavaClass
  3. 方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。
  4. 源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记 Java 是大小写敏感的),文件名的后缀为 .java。(如果文件名和类名不相同则会导致编译错误)。
  5. 主方法入口:所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
  6. Java的注释方式同C++语言。

Java标识符

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

  1. 所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线(_)开始
  2. 首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线(_)或数字的任何字符组合
  3. 关键字不能用作标识符,标识符是大小写敏感的
  4. 合法标识符举例:age$salary_value__1_value
  5. 非法标识符举例:123abc-salary

2、Java枚举类型

枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

1
2
3
4
5
6
7
8
9
10
11
class FreshJuice {
enum FreshJuiceSize{ MEDIUM, LARGE, SUPERLARGE }
FreshJuiceSize size;
}

public class FreshJuiceTest {
public static void main(String[] args) {
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.SUPERLARGE;
}
}

3、Java的对象和类

Java是一种面向对象的语言,支持:多态、继承、封装、抽象、类、对象、实例、方法、重载。

  • 对象:对象是类的一个实例,具有状态和行为。
  • 类:类是一个模板,描述一类对象的行为和状态。

创建对象

创建对象分3步:

  1. 声明:声明一个对象,包括其名称和类型;
  2. 实例化:使用关键字new创建一个对象;
  3. 初始化:使用new创建对象时,将会构造方法初始化对象。
1
2
3
4
5
6
7
8
9
10
11
public class Puppy {
// 下面构造器的参数只有一个 name
public Puppy(String name) {
System.out.println("the puppy's name is " + name);
}

public static void main(String[] args) {
// 创建对象 myPuppy
Puppy myPuppy = new Puppy("tommy");
}
}

访问实例变量和方法

直接看例子如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Puppy {
int puppyAge;
public Puppy(String name) {
System.out.println("the puppy's name is " + name);
}

public void setAge(int age) {
puppyAge = age;
}

public int getAge() {
System.out.println("the puppy's age is " + puppyAge);
return puppyAge;
}

public static void main(String[] args) {
Puppy myPuppy = new Puppy("tommy"); //创建对象
myPuppy.setAge(2); // 设定 age
myPuppy.getAge(); // 获取 age

// 访问成员变量
System.out.println("Age = " + myPuppy.puppyAge);
}
}

源文件的声明规则

  1. 一个源文件中可以有多个非 public 类,但只能有一个 public 类;
  2. 源文件的名称应该和 public 类的类名保持一致。例如:源文件中 public 类的类名是 Puppy,那么源文件应该命名为 Puppy.java
  3. 如果一个类定义在某个包中,那么 package 语句应该在源文件的首行。
  4. 如果源文件包含 import 语句,那么应该放在 package 语句和类定义之间。如果没有 package 语句,那么 import 语句应该在源文件中最前面。
  5. import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中,不能给不同的类不同的包声明。
  6. java因强制要求类名(唯一的public类)和文件名统一,因此在引用其它类时无需显式声明。在编译时,编译器会根据类名去寻找同名文件。

一个简单的实例

首先新建一个文件:Employee.java 如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.io.*;

public class Employee{
String name;
int age;
String designation;
double salary;
// Employee 类的构造器
public Employee(String name){
this.name = name;
}
// 设置age的值
public void empAge(int empAge){
age = empAge;
}
/* 设置designation的值*/
public void empDesignation(String empDesig){
designation = empDesig;
}
/* 设置salary的值*/
public void empSalary(double empSalary){
salary = empSalary;
}
/* 打印信息 */
public void printEmployee(){
System.out.println("名字:"+ name );
System.out.println("年龄:" + age );
System.out.println("职位:" + designation );
System.out.println("薪水:" + salary);
}
}

Java程序从main函数开始执行,因而还需要另外一个包含main方法的java文件:EmployeeTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.*;

public class EmployeeTest{
public static void main(String[] args){
/* 使用构造器创建两个对象 */
Employee empOne = new Employee("RUNOOB1");
Employee empTwo = new Employee("RUNOOB2");

// 调用这两个对象的成员方法
empOne.empAge(26);
empOne.empDesignation("高级程序员");
empOne.empSalary(1000);
empOne.printEmployee();

empTwo.empAge(21);
empTwo.empDesignation("菜鸟程序员");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}

4、Java的基本数据类型

Java语言包含内置数据类型引用数据类型两种。

内置数据类型

Java提供了8种基本数据类型,包括:

  • 4种整数型数字类型(byte, short, int, long)
  • 2种浮点型数字类型(float, double)
  • 1种字符类型(char)
  • 1种布尔类型(boolean)

一个例子直接展示以上数据类型的包装类,二进制位数(xxx.SIZE),最小值(xxx.MIN_VALUE),最大值(xxx.MAX_VALUE):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class PrimitiveTypeTest {  
public static void main(String[] args) {
// byte,默认值为 0
System.out.println("基本类型:byte 二进制位数:" + Byte.SIZE);
System.out.println("包装类:java.lang.Byte");
System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();

// short,默认值为 0
System.out.println("基本类型:short 二进制位数:" + Short.SIZE);
System.out.println("包装类:java.lang.Short");
System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();

// int,默认值为 0
System.out.println("基本类型:int 二进制位数:" + Integer.SIZE);
System.out.println("包装类:java.lang.Integer");
System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();

// long,默认值为 0L
System.out.println("基本类型:long 二进制位数:" + Long.SIZE);
System.out.println("包装类:java.lang.Long");
System.out.println("最小值:Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值:Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();

// float,默认值为 0.0f
System.out.println("基本类型:float 二进制位数:" + Float.SIZE);
System.out.println("包装类:java.lang.Float");
System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();

// double,默认值为 0.0d
System.out.println("基本类型:double 二进制位数:" + Double.SIZE);
System.out.println("包装类:java.lang.Double");
System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();

// char,默认值为 'u0000',String类型的默认值是 null
System.out.println("基本类型:char 二进制位数:" + Character.SIZE);
System.out.println("包装类:java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值:Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值:Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);

// boolean的默认值为 false
}
}

引用数据类型

  1. Java中的引用类型变量类似于C++中的指针。引用类型指向一个对象,指向对象的变量是引用变量。且此变量一旦声明后,无法改变;
  2. 对象和数组都是引用数据类型;
  3. 所有引用类型的默认值都是null
  4. 一个引用变量可以用来引用任何与之兼容的类型;
  5. Site site = new Site("dog")

Java常量

在Java中,使用final关键词修饰常量:

1
final double PI = 3.1415926;

注意:通常使用大写字母表示常量。

在Java中,byteshortintlong 都可以使用十进制、16进制、8进制表示:

1
2
3
int decimal = 100;
int octal = 0144;
int hexa = 0x64;

Java的自动类型转换

转换由低级到高级如下:

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

在数据类型转换时,需要满足以下规则:

  1. boolean类型数据无法转换;
  2. 不能把对象类型转换成不相关类的对象;
  3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换;
  4. 转换过程中可能导致溢出或损失精度,例如:
1
2
3
int i =128;
byte b = (byte)i;
// byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
  1. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:
1
2
(int)23.7 == 23;
(int)-45.89f == -45;

Java的强制类型转换

要求:

  1. 条件是转换的数据类型必须是兼容的;
  2. 格式:(type)value,其中type是要强制类型转换后的数据类型。

实例如下:

1
2
3
4
5
6
7
public class QiangZhiZhuanHuan{
public static void main(String[] args){
int i1 = 123;
byte b = (byte)i1;//强制类型转换为byte
System.out.println("int强制类型转换为byte后的值等于"+b);
}
}

Java隐含强制类型转换

  1. 整数的默认类型是 int
  2. 浮点型不存在这种情况,因为在定义 float 类型时必须在数字后面跟上 F 或者 f

参考链接

  1. 菜鸟教程:Java基础语法
  2. 菜鸟教程:Java对象和类
  3. 菜鸟教程:Java基本数据类型