Java基本语法

本文将从基本数据类型、控制语句、类等方面来简述Java语言的基本语法。

1 基本数据类型

1.1 整数

1个字节为8位2进制数，能容下的数据为2^8 = 256种，unsigned表示无符号变量，不存在负值，故unsigned int的范围是0 ~ 255，以此类推

1.2 浮点数

尾数位计算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 访问修饰符

修饰符用于控制变量和类的作用及其访问限制，作用关系如下表：

成员变量一般用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());
    }
}

作者：迷路的丸子
链接：https://www.jianshu.com/p/8ea292e2ca9c