Java学习笔记——小白快速入门

本人现在是计科专业的苦*大二仔，在大一已经学过一年的C++基础知识，漫漫寒假想打发时间，想到大二下有Java的课程，于是花了半天时间快速入门了一下Java基础语法。Java的代码风格跟C++有很多的类似之处，网上的网课从头到尾看实在是食之乏味没有必要。本文针对有一定C++学习基础的同学，如果你想要在短短几个小时内掌握Java基础语法并且自己动手编写简单的Java程序的话，相信本文能帮你做到这一点。(oﾟ▽ﾟ)o

1.准备工作

在编写第一个Java程序之前，首先需要配置环境变量等。╮(─▽─)╭

IDEA 2019及JDK 12下载链接：
https://pan.baidu.com/s/1A9Vb_aNO06QEbVu0zDbVIQ
提取码：zvcw

IDEA 全称 IntelliJ IDEA，是Java编程语言开发的集成环境。IntelliJ在业界被公认为最好的Java开发工具，尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn等)、JUnit、CVS整合、代码分析、 创新的GUI设计等方面的功能可以说是超常的。一句话，类比C++中的编译器VS。
JDK 即Java Develop Kit，是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个Java开发的核心，它包含了Java的运行环境（JVM+Java系统类库）和Java工具。一句话，如果你要运行Java程序，那么需要下载JRE，如果你要编译Java程序，那么需要下载JDK。
（花里花哨复制自百度百科…）

具体的安装步骤：
IDEA2019安装教程
JDK-12.0.2安装教程

细节在这里不再赘述，注意在添加环境变量时也可以采用直接添加的办法。安装过程中遇到的问题欢迎评论留言学习交流。
因为是语法入门，所以关于IDEA的具体使用不做详细论述，如果有使用问题我会给大家相关链接去参考(〃‘▽’〃)

2.Hello World！

学计算机专业的同学肯定对“Hello World！”不陌生，废话不多说，直接上代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

短短的代码实际上蕴含了大大的玄机!!!∑(ﾟДﾟノ)ノ
IDEA快速创建Java项目
第一行看到的public和class关键字是不是很熟悉呢？其实和C++中的public和class的含义很相似。Java的一个特点就是面向对象编程，“对象”一词可以说在Java中无处不在。public class即定义了一个公共的类，类名为HelloWorld，这里要注意一下命名规范。

第一行后面所跟的{}里面就是类体（class body）了。

第二行的public关键字和第一行的public关键字的含义略有不同，表示的是公共方法（方法这个说法就和C++中的函数类似，在Java和Python中习惯说方法一词）。static关键字表示的是静态方法，跟C++中的static关键字含义不太一样，静态方法可以直接访问，不需要实例化，这里可以先记住这一点，后面会有详细介绍。void表示方法的返回值为空，含义与C++中类似。main类似于C++中的主函数，在Java中表示的是主方法，是入口函数，程序从这个方法进入并开始执行，后面在程序流程控制中还会提到。(String[] args)是main方法的参数，类型是字符串数组类型。

第二行后面所跟的{}里面就是方法体（method body）了。

下面再看看第三行，也就是输出打印"Hello World"啦！System是JDK自带的一个类（类无处不在orz），out是一个静态变量，println方法是变量out里面的一个方法，作用是输出到控制台，其中的“ln”表示换行输出（其它输出方法等需要用到时可以自行查阅哦~）。"Hello World!"是字符串参数，就不用多说了吧？分号;表示语句的结尾，和C++一样。总之，这一行的作用就和C++中的cout啥噼里啪啦的一个作用，现在记住就可以啦！

但这里我们们就对一个完整的Java程序有了大概的了解，是不是很简单捏？d(´ω｀*)

Tips：在IDEA中可以输入main来快速键入主方法，输入sout来快速键入输出打印语句。

3.华味惭初识，新声喜尽闻

下面要讲的内容保证你一看就会！不会你顺着网线来打我！因为这些内容跟C++实在是太太太太相似啦！有些甚至就是一模一样！

1.数据类型

与Python，MATLAB等不同，Java与C++一样需要声明数据类型。int、double、long的等关键字在Java中你同样可以见到！和C++中的数据类型很相似，在后面的代码段中如果有不理解的地方或者在具体需要使用的时候可以去查阅一下~

下面的链接有需要的话可以浏览一下ヽ(￣▽￣)و
Java数据类型

2.Java运算

先贴一段代码给大家自己理解理解，相信都能看懂：

package Demo01;

public class Calculate {
    static void test() {
        int a = (int) (Math.random() * 100);
        int b = (int) (Math.random() * 100);
        System.out.println("a=" + a);
        System.out.println("b=" + b);

        int result;//算术运算：+ - * / %
        result = a + b;
        System.out.println("a+b=" + result);
        result = a - b;
        System.out.println("a-b=" + result);
        result = a * b;
        System.out.println("a*b=" + result);
        result = a / b;
        System.out.println("a/b=" + result);
        result = a % b;
        System.out.println("a%b=" + result);

        boolean charge;//关系运算：> >= < <= == !=
        charge = a > b;
        System.out.println("a>b?:" + charge);
        charge = a < b;
        System.out.println("a<b?:" + charge);
        charge = a >= b;
        System.out.println("a>=b?:" + charge);
        charge = a <= b;
        System.out.println("a<=b?:" + charge);
        charge = a == b;
        System.out.println("a==b?:" + charge);
        charge = a != b;
        System.out.println("a!=b?:" + charge);
    }

    public static void main(String[] args) {
        test();
    }
}

Java中的运算符和C++中的十分类似，甚至很多都是一样的，这里就不再过多介绍，相信大家都看得懂，也可以把这段代码复制下来自己运行试试看。逻辑运算符会在后面用到时再拿出来讲一下，其实跟C++差别也不大。Java中Math工具类的random()方法可以生成[0,1)之间的随机浮点数。这里把double类型数据乘一百后强制转换成int类型，即随机生成一个[0,100)之间的数。

3.字符串与数组

Java里的字符串与数组同样和C++里的很类似，只是在具体的书写格式上有一些区别，通过下面这两段代码大家应该能掌握一些基本的方法。

1.字符串示例

package Demo01;

public class Str_Arr {
    static void teststr() {
        String s1 = "Hello ";
        String s2 = "World!";
        //字符串连接
        System.out.println(s1 + s2); //Hello World!

        String name = "Jack";
        int age = 20;
        String sex = "男";
        double salary = 5000.5;
        //字符串格式化
        String msg = String.format("姓名：%s,年龄：%d,性别：%s,薪水：%.2f", name, age, sex, salary);
        System.out.println(msg); //姓名：Jack,年龄：20,性别：男,薪水：5000.50

        String s = "Hello World!";
        System.out.println(s.charAt(0)); //H
        System.out.println(s.length()); //12
        System.out.println(s.indexOf("World")); //6
        System.out.println(s.substring(2, 7)); //llo W

        String ss = "    Hello World!    ";
        //去掉字符串首尾空格
        System.out.println(ss.trim()); //Hello World!
    }

    public static void main(String[] args) {
        teststr();
    }
}

这里需要注意的是第15行——字符串的格式化，双引号里面的实际上是一段字符串，其中的%s、%d这种%+字母的格式表示的是占位符，就好像是在这段字符串中占了一个位置。字符串后面的name、age等就是来填充前面占位符位置的。至于%后面加的字母分别是什么含义，其实可以参考C语言中的输出格式控制，s是字符串，d是整数，f是浮点数，前面的.2表示精确到小数点后两位。如果想要深入了解可以参考下面的链接：
Java字符串格式控制
因为只是带大家快速入门，这里只列举了几个常用的字符串方法，具体使用时想用更多的方法可以参考下面的链接：
Java中字符串的常用方法
代码中其他的内容都很简单，大家可以自行运行体会一下。

2.数组示例

package Demo01;

import java.util.Arrays;

public class Str_Arr {
    static void testarr() {
        int[] arr = {1, 2, 3, 4};
//      int arr[]={1,2,3,4}; //这样写也可以，但是Java中更习惯于用上面的那种格式

        int[] arr2 = new int[5];
        System.out.println(arr2[4]); //默认以0来初始化
        System.out.println(arr2[arr2.length - 1]);
        arr2[0] = 1000;
        System.out.println(arr2[0]); //输出为1000

        int[] testSort = {8, 2, 4, 5, 9, 0, 3, 7, 1, 6};
        Arrays.sort(testSort); //数组元素排序
        for (int i : testSort) { //for-each循环遍历数组
            System.out.print(i + " ");
        } //输出为0 1 2 3 4 5 6 7 8 9
        int index = Arrays.binarySearch(testSort, 3); //二分查找
        System.out.println(index); //输出为位置值3
    }

    public static void main(String[] args) {
        testarr();
    }
}

关于数组的操作不需要介绍太多，我在这里解释再多还不如你把上面的代码复制下来跑一边自己看看结果ヾ(=･ω･=)o

使用过C++的同学，这段代码只需要过一遍都能看懂啦，其中的for-each循环会在下面一个版块中介绍，不过相信大家应该都能猜出来这个怎么用啦。Arrays跟上面的Math一样是一个工具类，功能还是蛮强大的，具体的使用可以参考以下链接：
Java类库：Array类、Arrays类

4.程序流程控制

图源水印

Java中的程序流程控制跟C++相差无几（朴实而且枯燥…），在这里直接告诉大家基本上都是继承自C++，就不啰嗦了…想过一遍的可以参考以下链接：
Java程序流程控制

4.面向对象编程

到这个部分，才算是真正进入了Java的核心部分，同时恭喜你，这篇文章终于快要看完啦！还是一样粗暴的先贴上代码：

package Demo01;

public class myProject {
    public static void main(String[] args) {
        Person Jack = new Person("Jack",20);
        Person Rose = new Person();
        _Tom Tom = new _Tom();

        Animal miaomiao=new Cat();
        Animal wangwang=new Dog();
        Animal jiujiu=new Bird();

        Jack.care(miaomiao);
        Jack.care(wangwang);
        Jack.care(jiujiu);
        Rose.name="Rose";
        Rose.age=19;
        Tom.care(miaomiao);
    }
}

interface Animal{
    public void eat();
    public void play();
    public void sleep();
}

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("dog eat...");
    }

    @Override
    public void play() {
        System.out.println("dog play...");
    }
    @Override
    public void sleep() {
        System.out.println("dog sleep...");
    }
}

class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("cat eat...");
    }

    @Override
    public void play() {
        System.out.println("cat play...");
    }
    @Override
    public void sleep() {
        System.out.println("cat sleep...");
    }
}

class Bird implements Animal {
    @Override
    public void eat() {
        System.out.println("bird eat...");
    }

    @Override
    public void play() {
        System.out.println("bird play...");
    }
    @Override
    public void sleep() {
        System.out.println("bird sleep...");
    }
}

class Person{
    String name;
    int age;
    public Person (){

    }
    public Person (String name , int age){
        this.name=name;
        this.age=age;
    }
    public void care(Animal a){
        a.eat();
        a.play();
        a.sleep();
    }
}

class _Tom extends Person
{
    String name = "Tom";
    int age = 21;

    @Override
    public void care(Animal a) {
        super.care(a);
    }
}

1.类

浏览过刚才这段代码的同学不难发现，这里面有很多风格和C++相似的类的定义，什么猫类呀，狗类呀之类的。尽管在C++中已经有一定的面向对象编程的基础了，作为铺垫，还是在这里提一下类的定义。

类：类是一个模板，它描述一类对象的行为和状态。
对象：对象是类的一个实例，有状态和行为。

举个栗子，上述代码中的Cat就是自己定义的一个猫类，它只是一个模板，而miaomiao则是这个猫类的实例，是一个对象，一只实实在在的猫（仅针对这段代码而言啦）。它有名字：miaomiao；它能做一系列的事情：eat、play、sleep。学习过C++的同学是不是唤起了一些尘封中的记忆了呢？∠( °ω°)／

Java中想要定义一个类也是十分简单，大家可以类比C++进行学习：

1.基本框架：

(修饰符) class (类名)
{
//成员变量
//构造方法
//方法
//其它初始化模块
}

例如上面代码中的person类：

class Person{
    String name;
    int age;
    public Person(String name , int age){
        this.name=name;
        this.age=age;
    }
    public void care(Animal a){
        a.eat();
        a.play();
        a.sleep();
    }
}

2.访问权限：

Java有四种访问权限，其中三种有访问权限修饰符，分别为private，public和protected，还有一种不带任何修饰符default。

private：一般称之为“私有的”，被其修饰的内部类属性、方法只能被该类访问，其他任何类均没有权限访问。

default：默认访问权限(有时也称为friendly)，被其修饰的外部类、属性、方法只能在同一个包中访问。

protected：被其修饰内部类、属性、方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。

public：一般称之为“公有的”，被其修饰的外部类、属性、方法能被所有的类访问。

在这里补充一下Java中“包”的概念：

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。Java 使用包这种机制是为了防止命名冲突，访问控制，提供搜索和定位类、接口、枚举和注释等。

包的作用：
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

在src目录下右键即可快速创建一个包：

如，下图中的Demo01就是一个创建好的包：

关于访问权限中的细节，实在是一言难尽，大家可以自己尝试着写几段代码来看看其访问机制，这里就不赘述啦。

3.变量：

局部变量：在方法、构造函数或者语句块中定义的变量被称为局部变量。这个不用多说，在C++中大家已经见怪不怪了。

成员变量：也叫作实例变量。成员变量是定义在类中，方法体之外的变量。这个和C++中的一样，也不用多说。成员变量可被类中的方法、构造方法以及特定类的语句块访问。

静态变量：也叫作类变量。值得注意的是，类变量也声明在类中，方法体之外，但必须声明为static类型。静态成员属于整个类，可通过对象名或类名来调用。

4.构造方法：

构造方法可以有很多个，在缺省时使用默认构造方法。

public Person (String name){
        this.name=name;
    }
public Person (String name , int age){
        this.name=name;
        this.age=age;
    }

this关键字： 当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。

构造方法不能有任何的返回值，并且要求方法名和类名一致，这与C++中的规定相同。

5.方法：

方法就是函数，自定义的类能够做什么、具有哪些行为，就是通过方法来定义。方法的修饰符(public protected private)三选一、static、使用static就是静态方法了。这个就和C++中的成员函数一个道理，没有太多要说明的。

6.其它初始化模块：

是用来初始化一些值的，它的优先级比构造器要高，一些需要多次使用但又是固定的值可以放进初始化块中。使用static就是静态初始化块了，静态初始化块优先级是最高的。

class Fish{
    String name = "fish";
}

2.接口

1.定义：

它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型（Java中摒弃了指针等概念）。

(修饰符) interface (接口名称) {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}

例如上面代码中的Animal接口：

interface Animal{
    public void eat();
    public void play();
    public void sleep();
}

2.使用方法：

接口不能用来创建对象，但是可以被实现（implements，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

3.接口的实现：

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用== implements==关键字。

需要注意的是，非抽象子类实现接口：必须重写接口中所有抽象方法。继承了接口的默认方法，即可以直接调用，也可以重写。

class (类名) implements (接口名) {
// 重写接口中抽象方法（必须）
// 重写接口中默认方法（可选）
}

例如：

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("dog eat...");
    }

    @Override
    public void play() {
        System.out.println("dog play...");
    }
    @Override
    public void sleep() {
        System.out.println("dog sleep...");
    }
}

3.继承

在继承关系中一般两个角色，父类和子类，其中父类也叫超类，子类也叫派生类。比如Dog类和Animal类，Dog类就是子类，Animal类就是父类，其中子类也就是Dog类继承了父类也就是Animal类的非私有属性和方法，同时子类可以增加子类特有的属性和方法，并且子类可以重写父类的方法。使用继承可以减少大量的重复性代码，把公共的代码提取出来放到父类中同时也方便管理。

基本格式如下：

class (子类名) extends (父类名){
}

例如上面代码中的_Tom类：

class _Tom extends Person
{
    String name = "Tom";
    int age = 21;

    @Override
    public void care(Animal a) {
        super.care(a);
    }
}

这个世界上可能有很多人都叫Tom，所以定义这个_Tom类也不用太纠结，只是举个栗子哈~

注意，super关键字：

当我们要调用父类方法时使用。由于父类和子类都具有相同的命名方法，那么为了解决歧义，我们使用super关键字。

Java中的super关键字也是一个引用变量，与this关键字相对，用于引用父类对象。

具体的使用可以参考以下链接：
Java中的super关键字
这里不做过多展开。

4.多态

多态，简单来说，就是父类的引用变量指向子类对象。

例如在上面的代码中：

就是多态的一种实现了。

怎么理解呢？在上面的栗子中，Animal是动物接口，那么动物是一个抽象的概念，它有很多种形态，可以是猫呀，狗呀等等，这里的猫、狗其实就是一种多态。那么这个花里胡哨的东西到底有什么用呢？还是看上面的代码：

注意到，在自定义的Person类当中有一个care方法，这里面的参数是Animal 的对象a，这么做有什么好处呢？

假如我们把这里面的参数改成Cat cat，那么我们在main方法里调用person.care()方法的时候里面的参数就只能传入Cat类。什么意思呢？就是说这个人只能照顾猫。。。如果我们还想让他照顾狗、照顾鸟等其他的动物的话，那么我们只能进行方法的重载了，即定义多个方法名相同但参数不同的的方法，这样一来就会造成代码的大量重复使用。而且当我们新增某一个其它动物时就很不方便。比如，如果我们还想让这个人care一条鱼，那么我们必须再重写一遍care fish的方法。这样的程序可扩充性是很差的。而有了多态之后，我们可以把care方法里面的参数设置成Animal，这样我们在写care方法的时候就不需要重载了，在调用的时候直接输入Animal的子类对象就可以啦！是不是感觉有点绕？对着上面的代码在理解一下吧☆ヾ(=･ω･=)o

5.源文件声明规则

最后，简单源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

1.一个源文件中只能有一个public类
2.一个源文件可以有多个非public类
3.源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是myProject，那么源文件应该命名为myProject.java。
4.如果一个类定义在某个包中，那么package语句应该在源文件的首行。
5.如果源文件包含import语句，那么应该放在package语句和类定义之间.如果没有package语句，那么import语句应该在源文件中最前面。
6.import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

5.结语

到这里我们就对Java的基本语法解读完毕啦！

这是本人第一次写博客，有什么不对或是需要改进的地方还请指出，大家一起交流学习(>ω･* )ﾉ

Java语言博大精深，上面的内容只是带大家初步了解一下基本语法，稍微掀开一点Java神秘的面纱给大伙瞅瞅，我在后续会更新更多学习笔记和干货，喜欢的朋友可以关注支持一下呦╮(￣▽￣)╭