本文将从基本数据类型、控制语句、类等方面来简述Java语言的基本语法。
1 基本数据类型
1.1 整数
1个字节为8位2进制数，能容下的数据为2^8 = 256种，unsigned表示无符号变量，不存在负值，故unsigned int的范围是0 ~ 255，以此类推
| 类型 | 字节数 | 范围 |
|---|---|---|
| byte | 1 | -128 ~ 127 |
| short | 2 | -32768 ~ 32767 |
| int | 4 | -2147439648 ~ 2147438647 |
| long | 8 | / |
| unsigned byte | 1 | 0 ~ 255 |
| unsigned short | 2 | 0 ~ 65535 |
| unsigned int | 4 | 0 ~ 4294967295 |
| unsigned long | 8 | / |
1.2 浮点数
| 类型 | 字节数 | 指数位 | 符号位 | 尾数位 | 指数范围 | 数据范围 | 精度 |
|---|---|---|---|---|---|---|---|
| float | 4 | 8 | 1 | 23 | -128 ~ 127 | ±3.4E-38 ~ 3.4E38 | 6-7 |
| double | 8 | 11 | 1 | 52 | -1024 ~ 1023 | ±1.7E-308 ~ 1.7E308 | 15-16 |
尾数位计算2E23 = 8388608，故float最多能保留7位有效数字，绝对精准地保留6位；2E11 = 256，故float的指数范围为-128 ~ 127，因此2^127 = 3.4E38就是数据范围，可以此类推（没有unsigned）
1.3 字符和字符串
- 字符类型char占1个字节，'1','a','#',' '等都是字符
- 字符串类型String由长度决定占字节数，"asdas 124"是9个字节的字符串
1.4 boolean类型
- 只有true或false两种取值，表示真假
1.5 操作符
- '+' , '-' , '*' , '/' , '%' , '>' , '=='等都是操作符
1.6 数组
- 数组的声明与相关语句：
int array[100];
int[] array = new int[100];
array[0] = 5;
int length = array.length();
2 控制语句
2.1 逻辑判断
if (condition) { action1; } else { action2; }
2.2 循环
2.2.1 循环体结构
for (initial; condition; iteration) {}
for (T iterator : Collection<T>) {}
while (condition) {}
2.2.2 控制语句
- return <返回值>: 从⽅法中返回
- break: 退出当前循环
- throw: 抛出异常
3 类型模型
类：一个模板，它描述一类对象的行为和状态
对象：类的一个实例，有具体的状态
方法：类中定义的该类的实例对象所具有的行为
静态方法：隶属于类本身的方法
3.1 类
一般情况下，一个文件中存放一个public类，类的结构如下：
//程序包名
package com.company;
//类声明
public class Student {
//成员变量及方法
}
3.2 对象
语义上是表达一个Java类的尸体，可以赋值到一个变量，通过new语句进行创建
以Student类为例，首先在Student类中定义成员变量及构造函数：
public class Student {
//成员变量
private String name;
private int weight;
//无参的构造方法1
public Student() {
this.name = "default";
this.weight = 0;
}
//含参的构造方法2
public Student(String name, int weight) {
this.name = name;
this.weight = weight;
}
//静态构造方法
public static Student newStudent(String name, int weight){
return Student(name, weight);
}
}
在Main函数中创建对象：
public class Main {
public static void main(String[] args) {
//Student default，构造方法1
Student def = new Student();
//Student Jeff,构造方法2
Student jef = new Student("Jeff",120);
//Student Jimmy,静态构造方法
Student jimmy =Student.newStudent("Jimmy", 130);
}
}
3.3 修饰符及方法
3.3.1 访问修饰符
修饰符用于控制变量和类的作用及其访问限制，作用关系如下表：
| / | public | protected | default | private |
|---|---|---|---|---|
| 同一个类 | √ | √ | √ | √ |
| 同一个包 | √ | √ | √ | × |
| 子父类 | √ | √ | × | × |
| 不同包 | √ | × | × | × |
成员变量一般用private修饰，能增加其安全性，对其进行保护。这样外部方法就不能通过jef.name等方式直接访问成员变量。相对地，通过getter和setter函数为外部方法提供可读和可写接口：
public class Student {
...
//getter方法为外部提供可读接口
public String getName(){
return name;
}
//setter方法为外部提供可写接口
public void setName(String name) {
this.name = name;
}
}
从而外部方法可以通过以下方式对Student类的成员变量进行访问：
public class Main {
public static void main(String[] args) {
...
//可读
System.out.println(def.getName());
//System.out.println(def.name);错误，不具有访问权限
//可写
jef.setName("David");
//jef.name = "David";错误，不具有访问权限
}
}
3.3.2 静态修饰符
- static：把方法或者成员变量设置为类共享，可以通过类名直接访问，声明方式：
public class Student {
...
//静态变量
public static int number = 0;
//构造方法改变静态变量，对创建的实例对象进行计数
public Student() {
this.name = "default";
this.weight = 0;
number++;
}
public Student(String name, int weight) {
this.name = name;
this.weight = weight;
number++;
}
//静态方法
public static int getNumber() {
return number;
}
}
要注意的是，静态方法没有this,非静态变量不能在静态方法中访问，但静态变量可在非静态方法中访问
3.3.3 final修饰符
final修饰符主要有三个作用：
- final <类>; ->防止类被继承
- final <变量>; ->防止变量被修改引用到另外一个对象，可称为常量
- final <方法>; ->防止方法被重载<override>
final <变量> 必须在声明或者构造函数中定义，用声明定义示例：
public class Student {
...
final private String name = "default";
}
用构造函数定义示例：
public class Student {
...
final private String name;
public Student(String name, int weight) {
this.name = name;
this.weight = weight;
}
}
但是，当声明中定义了final成员变量，就不可以在构造函数中修改其值及引用
这里有个问题：常量指向的对象能否被修改？
final <对象> 可以从下探究：
public class Main {
public static void main(String[] args) {
...
final Student fin = new Student("FIN",150);
//fin = jef; 错误，重新引用
fin.setName("FII"); //正确，可以改变对象内成员
}
}
因此，常量指向的对象本身不可以被修改，但其成员变量可修改
3.4 注意
变量可以通过直接传值于变量，但对象不能直接传值于对象，简单赋值只能进行引用，即浅拷贝，指向统一对象：
public class Student {
...
public void workout() {
weight = weight - 5;
}
}
public class Main{
public static void main(String[] args) {
...
Student jef = new Student("Jeff",120);
Student david = jef;
david.workout();
System.out.println(david.getWeight());
System.out.println(jef.getWeight());
}
}
其结果均为115，可见jef和david均指向同一对象，其成员变量同时改变，该方法属于浅拷贝
- 深拷贝方法
public class Student implements Cloneable{ //将类声明附加可克隆功能
...
public Object clone() { //克隆方法
Object o = null;
try {
o = super.clone();
}
catch (CloneNotSupportedException e) {
System.out.println(e.toString());
}
return o;
}
}
public class Main {
public static void main(String[] args) {
...
Student jeff = new Student("Jeff",120);
Student david = (Student)jeff.clone(); //深拷贝测试
david.workout();
System.out.println(david.getWeight());
System.out.println(jeff.getWeight());
}
}
程序输出结果为115和120，说明david与jef是独立的对象，其变化互不影响，深拷贝成功
网友评论