Java学习笔记(一)——基本特性

Posted on 2022-02-19 Edited on 2023-02-24 In Java Word count in article: 7.7k Reading time ≈ 7 mins.

前言

Java语言相关基础知识的学习，主要参考菜鸟教程上的相关知识。

（一）主要特性

相较于之前接触过的C、C++的一些独特特性有：

1、简单

Java语言的语法和C、C++接近，容易理解。另外，其丢弃了C++中很少使用、较难理解的一些特性：操作符重载、多继承、自动强制类型转换。特别的是：Java不使用指针，而是引用。并提供自动分配和回收的内存空间。

2、面向对象

Java提供类、接口和继承等面向对象的特性。为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements）。Java 语言全面支持动态绑定，而 C++语言只对虚函数使用动态绑定。

3、分布式

Java支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。

4、强势

Java 具有强类型机制、异常处理、垃圾的自动收集等特性，对指针的丢弃是 Java 的明智选择，同时其具有安全检查机制。

5、安全

Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外，Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵。

6、中立性

Java 程序（后缀为 java 的文件）在 Java 平台上被编译为体系结构中立的字节码格式（后缀为 class 的文件），然后可以在实现这个 Java 平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。

7、可移植性

这种可移植性来源于体系结构中立性，另外，Java 还严格规定了各个基本数据类型的长度。Java 系统本身也具有很强的可移植性，Java 编译器是用 Java 实现的，Java 的运行环境是用 ANSI C 实现的

8、解释性

解释性语言主要有：Javascript、PHP、java

编译性语言：C/C++

区别是：解释性语言，编译后的代码，不能直接被机器执行，需要解释器来执行，编译性语言编译后的代码可以直接执行。

Java 程序在 Java 平台上被编译为字节码格式，然后可以在实现这个 Java 平台的任何系统中运行。在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。

9、高性能

与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++。

10、多线程

在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。

11、动态

Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

（二）Java运行机制及运行过程

class后缀文件之所以拥有跨平台性，在多个系统上都可以运行。是因为JVM（java虚拟机）

JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域，负责执行指令、管理数据、内存、寄存器，包含在JDK中。
对于不同的平台，有不同的虚拟机
java虚拟机机制屏蔽了底层运行平台的差别，实现了跨平台性。

（三）JDK、JRE

JDK：Java Development Kit（Java开发工具包）=JRE+Java的开发工具【java、javac、javadoc、Javap等】

JRE：Java Runtime Environment（Java运行环境）=JVM+Java SE标准类库（java核心类库）

（四）Java基础语法

下面简要介绍下类、对象、方法和实例变量的概念：

对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

1、一个简单的Java程序

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

在文件有中文的时候，可以设置编码为GBK即可显示。

2、基本语法

一些需要注意的语法

大小写敏感
类名：对于所有的类来说，类名的首字母应该大写。
方法名：所有的方法名都应该以小写字母开头。
源文件名：源文件名必须和类名相同。如果不同则会导致编译错误。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

3、Java修饰符

Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

4、Java变量

Java 中主要有如下几种类型的变量

局部变量
类变量（静态变量）
成员变量（非静态变量）

5、继承

在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（sub class）。

6、接口

在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

7、Java 源程序与编译型运行区别

（五）Java对象和类

Java作为一种面向对象语言。支持以下基本概念：

多态
继承
封装
抽象
类
对象
实例
方法
重载

通过上图创建一个简单的类：

public class Dog{
    String breed;
    int size;
    String colour;
    int age;
    
    //方法
    void eat(){
    }
    
    void run(){
    }
    
    void sleep(){
    }
    
    void name(){
    }
}

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

一个类可以拥有多个方法，在上面的例子中：eat()、run()、sleep() 和 name() 都是 Dog 类的方法。

1、构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

下面是一个构造方法示例：

public class Test{
	public Test(){
	}
	
	public Test(String name){
	//这个构造器只有一个参数：name
	}
}

2、创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：

public class Test{
    public Test(String name){
        //这个构造器仅有一个参数：name
        System.out.println("小狗的名字是：" + name);
    }
    
    public static void main(String[] args){
        //下面语句将创建一个Test对象
        Test myTest = new Test("tommy");
    }
}

3、访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法，如下所示：

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

具体实例：

public class Puppy {
    int puppyAge;
    public Puppy(String name){
        System.out.println("小狗的名字是:" + name);
    }

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

    public void getAge(){
        System.out.println("小狗的年龄是:" + puppyAge);
        //return puppyAge;
    }

    public static void main(String[] args){
        Puppy myPuppy = new Puppy("tom");
        myPuppy.setAge(5);
        myPuppy.getAge();
        System.out.println("小狗的年龄是:" + myPuppy.puppyAge);
    }
}

/*结果：
小狗的名字是:tom
小狗的年龄是:5
小狗的年龄是:5
*/

4、源文件声明规则

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

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

类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。这些将在访问控制章节介绍。

除了上面提到的几种类型，Java 还有一些特殊的类，如：内部类、匿名类。

5、Java 包

包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

6、import 语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

1	import java.io.*;

7、一个简单的例子

在该例子中，我们创建两个类：Employee 和 EmployeeTest。

首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为 Employee.java。

Employee 类有四个成员变量：name、age、designation 和 salary。该类显式声明了一个构造方法，该方法只有一个参数。

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);
   }
}

程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。

下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。

将下面的代码保存在 EmployeeTest.java文件中。

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();
   }
}

编译这两个文件并且运行 EmployeeTest 类，可以看到如下结果：

$ javac EmployeeTest.java
$ java EmployeeTest 
名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0

（六）Java文档注释

/**
	*@author Cloudyun
	*@version 1.0
*/

上面例子即为Java的文档注释，注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档，一般写在类

如何应用生成？

1	javadoc -d 文件夹名 -author -version -... Test.java