JAVA基本语法+面向对象

类的构造方法#

构造方法是类在构造对象时执行的过程，是对所创建的对象实体的初始化，Java的构造方法其实就是C++中的构造函数，只不过C++的构造函数可以使用初始化列表，而Java没有初始化列表。下面是一个定义类的例子：

1
class Example{
2
    int x ;
3
    String s ;
4
    int add3(int a){
5
        return a + 3 ;
6
    }
7
    Example(){
8
        x = 10 ;
9
        s = null ;
10
    }  //Example类的构造方法
11
}

当一个类没有定义构造方法时，系统会自动生成一个默认的构造方法，默认的构造方法没有方法体，类内的属性所得到的初始值是默认值，如 int默认值是0，boolean默认值是false。

对象的实现#

创建对象的实现，需要通过new运算符+构造方法来实现。如：

1
Example a = new Example();

其中变量a是引用变量，new Example()创建了一个对象实体，引用变量a指向了这个实体，关于这些的具体解释，我们放到后面的引用数据类型中再进行详细说明。 通过new还可以创建匿名对象，匿名对象是没有 指向它的变量 的对象，相当于没有名字。

输出#

Java的输出比输入简便，主要原理就是调用标准的输出流(System.out)来进行输出，让我们回到梦开始的地方：

1
public class Hello{
2
    public static void main(String[] args){
3
        System.out.println("Hello world!");
4
    }
5
}

上面的println是print line的缩写，它在输出内容后会自动换行，System.out的成员中还有print、printf等，print在输出内容后不会自动换行(这一点与python不同)，printf是print format，是指定格式的输出，用法与C/C++的printf类似。

输入#

Java的输入需要引入一个Scanner类，并通过Scanner类创建对象并且于标准输入流(System.in)绑定，通过这个对象实现输入操作，下面是一个简单的例子：

1
import java.util.Scanner;
2
public class test{
3
    public static void main(String[] args){
4
        int x ;
5
        Scanner reader = new Scanner(System.in);
6
        x = reader.nextInt();
7
        System.out.println(x);
8
    }
9
}

其中对于Scanner reader = new Scanner(System.in);这行，我们也放到后文的“引用数据类型”中再作详细解释。

基本数据类型#

Java的基本数据类型有：布尔型(boolean)、字节型(byte)、字符型(char)、短整型(short)、整型(int)、长整型(long)、单精度浮点型(float)、双精度浮点型(double)。（没有字符串型哦，或者说，字符串类型不是基本数据类型），与C/C++不同，Java中没有long long和usigned(无符号)类型。下面是这些基本数据类型的大致介绍。

boolean：布尔型，常量只有两个值：true和false。（注意：true和false是两个值，不是关键字）

byte：字节型，顾名思义，是占一个字节的整型，数据表示范围是-128到127的整型数据。Java中不存在byte型常量的表示方法，但可以把1个字节范围内的整型赋值给byte型变量。

char：字符型，Java中的字符使用Unicode编码，占两个字节，这点与C/C++的char类型不同。所以在之后的Java程序中你可能会见到类似这样的命名：

1
int 年龄 = 18 ;
2
char 爪洼 = '哇' ;

注：Java代码中的单引号、分号和等号等符号仍然要用英文。

short：短整型，是比整型短，比字节型长的一种数据类型，通常占2字节。Java中不存在short型常量的表示方法，但是可以把2个字节范围内的整型赋值给short型变量。

int：整型，这个就是众所周知的整型，通常占4字节。整型常量就是整数，例如32.

long：长整型，比整型长的一种数据类型，通常占8字节。长整型常量是整数+后缀L，例如：32L。（注意是大写L，在IDEA中用小写l的话会提示改成大写，而且小写l容易与数字1混淆）。

float：浮点型，是用来存放小数的数据类型，在《Java2实用教程(第五版)》一书中介绍的float可以保留8位有效数字，通常占4字节。float类型常量是小数+后缀f或F，例如：3.14f，5.20F。

double：双精度浮点型，精度比float高，上书中介绍的double可以保留16位有效数字，通常占8字节。double类型常量就是我们平时所见的小数，如：3.14，5.20。

小结：Java中的byte和short没有对应的常量表示，其它不加后缀的数字是int型或double型的常量，字符类型是2字节。

在C/C++中，在涉及到数据间的赋值和运算时，经常涉及到类型转换的问题，Java中也是如此，既可以隐式转换（自动转换），也可以显式转换（手动转换）。C/C++中可以随意地隐式转换，无非就是精度损失的问题，但是在Java中，那个严格的检察官可不允许这样。

之前在看书或者实践过程中，被Java的数据转换玩的团团转，杂乱无章的转换规则我难以接受，所以后来找了一个规律，这个规律应该是没有问题的，如果发现有错还请及时联系小编更正。

先看个图（作图水平有点次，那个小方框里的X代表“错号”，表示“路径不通”，不知道我画这幅图的软件怎么在曲线上打叉 ）：

在 没有强制类型转换（显式转换）的情况下：

• 当变量赋值给变量时（即赋值号右边是变量时）：如果上图中的右边赋值给左边，则报错；左边赋值给右边，是可以的。
• 当常量赋值给变量时（即赋值号右边是常量时）：在分割线往右（包括long类型 常量 赋值给int 变量），如果上图中的右边类型的 常量 赋值给左边类型的 变量，则报错；如果左边类型的 常量 赋值给右边类型的 变量，是可以的。在分割线往左，右边类型 常量 可以赋值给左边类型 变量（包括int常量赋值给byte变量也是可以的）。

如果有显示转换：

只要赋值号两端类型一致，则没有问题，如果类型不一致，则仍然是上述规律。

下面是一些不同类型赋值的例子，第8、10、12、15行红色波浪线处是错误的赋值，编译器会报错

有没有发现，上面所说的类型里面没有boolean型，它貌似被孤立了一样，实际上，boolean与其他任何类型都不能隐式转换，直接赋值也会报错，不过boolean强制转换(显式转换)成int时，true会变成1，false会变成0。

当遇到赋值时编译器报错的情况，只要不担心精度损失的问题，就可以直接强制转换，毕竟强制类型转换的主动权还是在自己手里的，就算是再严格的检察官也不敢说你错。检察官：君让臣转，臣不得不转。

引用数据类型#

上文 说到，Java中去除了指针，那么数组等需要用到地址的东西，它怎么实现呢？这个问题，被Java的引用数据类型巧妙化解。众所周知，Java和C++其中一个对于数组的区别就是：Java中数组下标越界会报错，但是C/C++不会。Java的引用变量，类似于C/C++的指针变量。引用数据类型，就类似C/C++的指针类型，不过Java的引用和C/C++的地址不完全一样，Java的引用是地址的重要信息，并非地址本身。在C++中也有引用，但是C++的引用和Java中的不同。我们先区别一下两者不不同：

C++的引用与其绑定的对象共用同一块内存，对其中任何一者操作，都会影响到二者的内容。

Java的引用与其绑定的对象 不共用 内存，Java的引用变量里面存放着与其绑定的对象的地址的相关信息，它们是两块内存，通过引用访问对象其实就是一个寻址过程，这个过程与C/C++的指针类似。

Java的引用类型包括：字符串、数组、类、接口等。

以数组举例，众所周知，Java的数组定义是不允许直接指定长度的，这一点与C/C++不同，例如在Java中：

1
int a[] ;    //合法
2
int[] a ;    //推荐使用这种方式定义数组
3
int a[10] ;  //报错

int a[10]并不是创建引用变量也没有申请内存，Java中没有这样的语句，当有int a[10]这条语句时，Java编译器：这是个什么玩意？

既然不能直接指定长度，那我们想要一个长度为10的数组该怎么办呢？

对于身为引用数据类型的数组，其实我们的int[] a；这行代码，是定义了一个int[]类型的变量a，其中int[]是一种引用类型(也就是整型数组类型)，而a就是int[]型的变量，注意，这里的数组名a是 变量，这点与C/C++的数组也不同。对于指定长度的问题，我们先看另一个引用类型：

还记得本文开头介绍输入时Scanner reader = new Scanner(System.in);这行吗，这个是一个通过类来创建对象的过程，其中的Scanner是类名（注意类也是引用类型），而reader是一个引用类型的变量，new Scanner()是在内存中创建一个Scanner对象并计算出其地址信息的语句，至于括号里的System.in这个参数，这里会涉及到类的构造方法(C++中称为“构造函数”，其实两者是一个东西)，我们先不谈这个参数的问题。Scanner()是Scanner类的一个构造方法，new运算符最后计算出的是Scanner类的成员的引用值(即和地址重要信息相关的值)，系统看到new Scanner()这条指令时会做下面几件事：

为Scanner类的成员分配内存，然后Scanner类中执行构造方法中的指令(可以理解成对成员进行初始化)，这个过程是创建对象的过程，这件事是Scanner()的作用；

计算出Scanner成员的地址的重要信息，最终的计算结果通常是一个十六进制数，通过这些重要信息可以找到这些成员。

所以，Scanner reader = new Scanner(System.in);这条语句就是计算出了Scanner成员的地址信息，然后把这个信息赋给reader变量。换言之，reader这个引用类型变量里存着创建好的Scanner类的 对象 的地址信息。这个过程也称为reader变量和创建好的对象绑定。通过reader变量，可以调用相应对象的各种方法。这里注意区分：reader是一个变量(有时被称为对象变量，可以说是对象的名字)，它不是对象实体，通过Scanner()语句在内存中创建出来的那个东西才是对象实体，通过reader可以访问到那个对象。

了解过new语句后，我们再回到指定长度，我们通常见到的创建数组的方法是：

1
int[] a = new int[10] ;

这样的语句，这条语句就是在内存中申请10个整型长度的内存，然后计算出这些内存地址的信息，再赋值给引用变量a，这就是定义数组并指定长度的正确操作。

小结：引用是地址相关信息，并非地址本身，引用变量存放着这些地址信息。

分支#

分支的if和C/C++类似，可以嵌套，也可以if…else等，不过与C/C++不同的是，Java中的条件判断语句最终的结果只可以是boolean类型，没有 C/C++中0是false，非0是true的说法。

分支还有一种语句是switch，它的用法和C/C++基本相同，不过在较新版本的Java中，switch还的case还支持->，下面是一个简单的例子：

1
int x = 3 ;
2
switch(x){
3
    case 1 -> System.out.println("is 1");
4
    case 2 -> System.out.println("is 2");
5
    default -> System.out.println("oh");
6
}

可以发现，通过->，可以省去写case中的break语句。

循环#

Java的循环与C/C++基本相同，不过还是有条件判断语句的差别。我们也可以通过break，continue语句控制循环的执行，控制效果和C/C++相同，这里不再赘述。

一般的父子类#

继承在Java中用extends来表示，举个栗子：

1
public class test{
2
    public static void main(String[] args){
3
        Student zhangsan = new Student() ;
4
    }
5
}
6

7
class Person{
8
    String name ;
9
    int age ;
10
}
11

12
class Student extends Person{
13
    int grade ;
14
}

这里的Person拥有姓名和年龄两个属性，而Student既有姓名和年龄，又有成绩，那么这时我们可以把Student看作时Person的子类，Student的姓名和年龄这两个属性是从它的父类Person中继承下来的。此时zhangsan所指向的Student的对象就含有name,age,grade三个属性。

我们定义Person类时，没用extends。Java中没用extends的类，编译器会自动加上extends Object。也就是说，除了Object类外的所有类都会有一个父类，没用指定父类的类默认是Object的子类，可以把Object看作是万类之鼻祖。上面我们定义的Person类其实就是：

1
class Person extends Object{
2
    //......
3
}

密封类#

接下来再想一种情况，有些类它并不想让所有类都可以继承它的属性，就像皇帝并不想当所有人的爸爸，不想让所有人都可以去继承他的皇位或财产，这时这个 爸爸 父类就可以指定谁可以继承它的东西，Java中类似这样的类我们用sealed修饰，并且通过permits来指定谁可以继承它的东西。语句类似这样

1
sealed class A permits B,C,D...

表示：密封类A允许B,C,D…继承它的属性和方法。

不过，在定义B,C,D…这些类的时候，因为它们的父类A只指定了它们可以继承，如果我们这样：

1
sealed class A permits B{
2
    //......
3
}
4
class B extends A{
5
    //......
6
    (此时B含有A的属性和B的新属性)
7
}
8
class M extends B{
9
    //......
10
    (此时M含有A和B的属性以及M的新属性)
11
}

这会喜提一个报错，因为对于密封类的继承，要求子类明确这种密封关系，也就是说，子类要决定是否可以继续继承，谁可以继承，还是都可以继承。如果不可以继续继承(即断子绝孙)，则用final修饰子类，如果仍然保持密封，则和父类相似，用sealed修饰并且指定继承名单，如果要解除密封，则用non-sealed修饰，正确的继承如下：

1
sealed class A permits B,C,D{
2
    //......
3
}
4
final class B extends A{
5
    //......
6
}
7
sealed class C extends A permits E,F,G{
8
    //......
9
}
10
non-sealed class D extends A{
11
    //......
12
}

当然如果类A不想让任何类继承它的东西，也可以直接用final修饰类A：

1
final class A{
2
    //.......
3
}

还需注意一点，当类A指定了继承子类B,C，但是我们只定义了类C而没有定义类C，这时编译器会告诉我们：无法解析符号“C”，这是因为类A明确指定了它的子类B和C，但是编译器在当前的编译单元找不到类C。就好像皇帝指定了张三当太子，但是这个世界上没有张三这个人一样，编译器会懵住：C是个啥玩意，是你儿子嘛，然后报错。

子类构造方法#

在继承过程中，父类有自己的构造方法，子类并不会继承父类的构造方法，子类构造方法是编译器自己生成的，并非继承父类的，想要调用父类的构造方法，需要使用super关键字，通过super关键字可以调用父类(即超类)的属性、方法和构造方法。举个栗子：

1
class father{
2
    int fx ;
3
    String fname ;
4
    father(){
5
        fx = 1 ;
6
        fname = null ;
7
    } //无参数的构造方法
8
    father(int x , String s){
9
        fx = x ;
10
        fname = s ;
11
    } //有参数的构造方法
12
    void speakOI(){
13
        System.out.println("oi!");
14
    }
15
}
16
class son extends father{
17
    double sy ;
18
    son(int x , String s , double y){
19
        super(x , s);    //调用父类的构造方法
20
        sy = y ;
21
    }
22
    void valueToX(int x){
23
        super.fx = x ;   //调用父类属性，等同于fx = x ;
24
    }
25
    void speak(){
26
        super.speakOI(); //调用父类方法
27
    }
28
}

其中调用父类的属性和方法时可以直接调用，也可以通过super关键字调用，但是父类的构造方法必须使用super关键字调用，而且参数要对应。上面的例子是调用了父类有参数的构造方法，对于son类的构造方法，我们还可以这样：

1
son(int x , String s , double y){
2
    super();   //调用父类的无参数的构造方法
3
    sy = y ;
4
}//此时参数列表里的x和s没用

或这样：

1
son(double y){
2
    super();   //调用父类的无参数的构造方法
3
    sy = y ;
4
}

在父类和子类都没用定义构造方法的情况下，如果我们这么写：

1
class A{
2
    int x ;
3
}
4
class B extends A{
5
    double y ;
6
}

对于类B，编译器会自动生成一个类B的构造方法，这个构造方法通常是这样的：

1
B(){
2
    super();
3
}

其实，对于每个类，在这个类的构造方法第一行编译器都会自动加上super();语句(在父类含有无参数的构造方法的情况下，当父类没有定义任何构造方法时，系统会自动生成一个构造方法，这个也是无参数的)。那么如果父类不含有无参数的构造方法呢，这时就需要手写构造方法，否则会喜提一个报错，下面是一个父类没有无参数的构造方法的例子：

1
class A{
2
    int xA ;
3
    double yA ;
4
    A(int x , double y){
5
        //这里有一个默认的super();
6
        xA = x ;
7
        yA = y ;
8
    }//类A的构造方法，此时不会自动生成类A的默认构造方法
9
}
10
class B extends A{
11
    int xB ;
12
    B(int x , double y , int xx){
13
        super(x , y);    //写super();或者不写这一行都会报错
14
        xB = xx ;
15
    }
16
}

这时类B的构造方法就必须通过super(参数)调用类A的构造方法。那为什么类A的构造方法也有一个默认的super();呢，这个super();调用的是谁的构造方法呢？答案就是上面说到的Object类，所有没有说明父类的类都被默认看作Object类的子类。

覆写#

继承中还有一个特点就是覆写，指的是子类可以对父类的某个方法的方法体做更改，但是不同于重载，覆写只能修改函数体，不可以修改参数列表。下面是一个例子：

1
class A{
2
    int returnANumber(){
3
        return 3 ;
4
    }
5
}
6
class B extends A{
7
    int returnANumber(){
8
        int i ;
9
        for( i = 1 ; i <= 3 ; i ++ ){
10
            if( i == 2 ) break ;
11
        }
12
        return i ;
13
    }
14
}

类B中的returnANumber方法就是对父类该方法的覆写。我们只是修改了函数体，没用修改参数列表和返回值类型（修改参数列表属于重载），如果将类B中returnANumber方法的返回值类型改成double则会报错。

关于这些继承，我们举个栗子，还是那个人类，还是那个学生类，但是学生又有好几种，比如小学生，中学生，大学生等。大学生一般会有科研、实践等。下面是一个简单的例子：

1
class Person{
2
    int age ;
3
    String name ;
4
    void speak(){
5
        System.out.println("I'm a person");
6
    }
7
    Person(){
8
        super(); //如果不写，系统会自动添加
9
    } //无参数的构造方法
10
    Person(int age , String name){
11
        this.age = age ;
12
        this.name = name ;
13
    } //有参数的构造方法
14
}
15
sealed class Student extends Person permits undergraduation{
16
    int grade ;
17
    void speak(){
18
        System.out.println("I'm a student");
19
    } //覆写
20
    Student(){
21
        super();
22
        grade = 100 ;
23
    } //无参数的构造方法
24
    Student(int age , String name , int grade){
25
        super(age , name);
26
        this.grade = grade ;
27
    } //有参数的构造方法
28
}
29
final class undergraduation extends Student{
30
    boolean research ; //科研
31
    boolean practice ; //实践
32
    void speak(){
33
        System.out.println("I'm a big student!");
34
        System.out.println("power!");
35
    } //覆写
36
    void speak(String s){
37
        System.out.println(s);
38
    } //重载
39
    undergraduation(){
40
        super();
41
        research = true ;
42
        practice = true ;
43
    }
44
    undergraduation(int age , String name , int grade , boolean x , boolean y){
45
        super(age,name,grade);
46
        research = x ;
47
        practice = y ;
48
    }
49
}

如果在Person类中不定义无参数的构造方法，那么后面的super();就会报错，因为此时Person已经有了一个构造方法，系统不会再自动生成默认的构造方法。