Java（二）Introduction to Java

Java学习

（一）Java学习
（二）Introduction to Java
（三）Java中的几个重要概念

---

---

一. compile & run

1. compile（编译）

定义

编译是将高级语言代码（如C, C++, Java）转换为机器语言（目标代码）的过程。这个过程由编译器完成。

过程

编译器读取源代码文件，进行词法分析、语法分析、语义分析、优化和代码生成，最终生成可执行的目标代码文件。

输出

输出的是目标代码文件，通常是二进制文件或者可执行文件。

特点

编译后的代码可以在不同的机器上执行，不依赖源代码。一次编译后可以多次执行。

2. run（运行）

定义

运行是指执行已经编译好的目标代码或解释型语言的源代码，使程序开始执行并产生结果。

过程

对于编译生成的目标代码，计算机会加载到内存，然后由操作系统将控制权转交给程序的入口点，程序开始执行。对于解释型语言，解释器会逐行解释源代码，并执行相应的操作。

输出

输出程序的执行结果，可以是在终端显示，生成文件，或者其他形式的输出。

特点

每次运行都需要进行解释或加载，依赖于目标代码或源代码。

---

二. Type checking

是在程序中检查变量、表达式和函数的类型是否符合预期的过程。它有助于发现在程序中可能导致类型错误的地方，并在编译时或运行时提前发现这些错误。

1. Static type checking : done at compile time

-Java / Haskell / C

2. Dynamic type checking : done at run time

-Python / LISP / Javascript

3. 类型检查的优点

• 提前发现错误： 类型检查可以在开发阶段或者早期发现可能的类型错误，避免在运行时出现问题。
• 提高代码质量： 明确的类型可以提高代码的可读性和可维护性。
• 优化性能： 编译器可以根据类型信息进行优化，提高程序的性能。

---

三. Structured Programming

Another paradigm that imposes a logical structure to code making it easier to understand and less error prone.

1. Structured control flow（结构化控制流）

“Structured control flow”（结构化控制流）是指编程中以结构化方式组织程序的流程和控制逻辑，以确保代码的清晰度、可读性和可维护性。它主要通过使用控制结构（如循环、条件判断、子程序）来实现。

基本的结构化控制流构造

Sequence（序结构）

程序按照代码编写顺序一步步执行，没有分支或循环。这是最简单的结构。

Selection（选择结构）

通过判断条件的真假来决定程序执行的路径。通常用 if、else if、else、switch 等条件语句实现。

Interation（循环结构）

允许程序多次执行同一代码块，直到满足退出循环的条件。通常用 for、while、do-while 等循环语句实现。

for (元素类型 变量名 : 集合或数组) {
    // 处理每个元素的代码
}

[Subroutine（子程序结构）]

将一段代码封装到独立的子程序或函数中，可以在程序中多次调用。这提高了代码的重用性和可维护性。

在结构化控制流中，避免了使用不受欢迎的 “goto” 语句，这种语句可能导致代码变得混乱、难以理解和难以维护。相反，通过合理使用选择、循环和子程序，代码的执行流程更易读、易懂、易维护。

2. Callable units（可调用单元）

“Callable units”（可调用单元）是指在程序中可以被调用（执行）的独立代码片段，这些代码片段可以被命名、重用，并接受输入参数和产生输出。可调用单元可以是函数、方法、过程或者子程序。

类型

函数（Function）

函数是一种可调用单元，接受输入参数，执行特定任务，并返回一个值给调用者。

方法（Method）

方法是与特定类或对象关联的函数。它们可以访问类的成员变量和其他成员函数，并且也可以返回一个值给调用者。

过程（Procedure）

过程类似于函数，但不返回值。它们执行一些特定任务或操作，但没有返回结果。

子程序（Subroutine）

子程序是通用术语，可以用于描述函数、方法和过程，是一个可重用的代码块。

可调用单元的使用有助于实现代码的模块化、重用和维护。通过将程序分解成小的、独立的可调用单元，可以更好地理解程序的逻辑、简化代码、提高代码的复用性，并使程序更易于测试和调试。

3. Block structure and scoping（块结构和作用域）

块结构（Block Structure）

块结构是指程序可以分解为多个代码块的能力。一个代码块是由一对花括号 {} 包围的语句集合。在许多编程语言中，这种结构允许在程序中嵌套使用代码块，形成层次化的代码组织结构。每个代码块可以包含变量、函数、控制流结构等。块结构有助于提高代码的可读性、模块化和重用性。

作用域（Scoping）

作用域是指在程序中访问变量的可见性和有效性范围。作用域规定了变量在何处可见和可以访问。常见的作用域类型有：

全局作用域（Global Scope）：

全局作用域中定义的变量可以在整个程序中访问。

局部作用域（Local Scope）

局部作用域中定义的变量只能在特定代码块内访问。

嵌套作用域（Enclosing Scope）

当存在嵌套代码块时，内部代码块可以访问外部代码块中的变量，但外部代码块无法访问内部代码块的变量。

非本地作用域（Nonlocal Scope）

用于嵌套函数，允许函数修改嵌套函数的变量。

作用域规则决定了程序中标识符的可见性和生命周期。通常，内部作用域可以访问外部作用域的变量，但反之则不成立。在涉及函数、模块和类等概念时，作用域非常重要，因为它们直接影响了变量的可访问性和安全性。

---

四. Abstraction

在Java中，抽象（Abstraction）是面向对象编程（OOP）中的一项重要原则和特性。抽象允许程序员通过隐藏实现细节，只展示对象的重要特征和功能来简化复杂性。这样，程序员可以关注于对象如何与其他对象交互，而不必了解其内部实现。

1. 实现方式

抽象类（Abstract Class）

抽象类是一种不能被实例化的类，它通常包含一些抽象方法和非抽象方法。抽象方法是没有具体实现的方法，而非抽象方法具有实现细节。子类继承抽象类并实现抽象方法。抽象类用于建模一些通用的行为和属性，但可能有一些特定实现由子类完成。

abstract class Shape {
    abstract void draw(); // Abstract method
}

抽象方法（Abstract Method）

抽象方法是没有实现体的方法，只有方法签名，用 abstract 关键字标识。抽象方法必须在抽象类中声明，但不包含实现。

abstract void draw();

抽象类和抽象方法提供了对细节进行抽象的机制，允许程序员在实际实现时填充细节。这样做有助于提高代码的模块化、可维护性和可扩展性。

2.主要形式

(1) Interface（接口）

Interface_oracle
interface_2
defining_interface
implement an interface
exercise

• 接口是一种抽象类型，它定义了一组抽象方法和常量，但没有实现。 在Java中，接口使用 interface
• 关键字声明。所有方法在接口中默认是抽象的，且接口中的字段默认是常量。 类可以实现一个或多个接口，通过 implements关键字实现接口的抽象方法。这允许类从多个不同的接口中继承方法规范，从而实现多继承的效果。
• 接口用于定义一组规范，强制实现类提供特定的功能。
• 不包含字段（成员变量）
• 无法被实例化（无法使用new关键字创建）：在Java中，接口不能直接实例化。这意味着你不能使用new关键字创建接口的对象。对象是类的实例，由于接口仅提供方法的签名而没有实际实现，因此它们没有创建实例所需的代码。

// 定义一个接口
interface Shape {
    void draw(); // Abstract method
}
// 实现接口的类
class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void display() {
        System.out.println("This is a circle.");
    }
}

• 接口中的方法默认情况下都是公共的（public），即它们具有公共访问权限。这意味着接口中定义的方法在实现类中需要使用 public 访问修饰符，以确保它们可以被其他类访问。

public class MyImplementation implements MyInterface {
    public void doSomething() {
        // 具体实现
    }
}

• can contain ( all implicit public)
  1. abstract methods ( method declaration without a body )
  • 这些抽象方法在接口中定义了方法签名，但具体的实现应该在实现该接口的类中提供。
  2. default methods ( using default modifier )
  • 默认方法是在接口中带有方法体的方法，它们提供了一个默认的方法实现，但可以在实现类中被重写。这使得在向现有接口添加新方法时，不会破坏已经实现该接口的类。
  3. static methods ( using static modifier )
  • 接口还可以包含静态方法（Static Methods），这些方法是接口的一部分，可以通过接口名称直接调用，而不需要创建接口的实例。静态方法通常用于提供某种与接口相关的功能，不依赖于接口的实例。
  4. constants ( implicit static final )
  • 接口可以包含常量（Constants），这些常量通常是公共的、静态的、final的（不可更改的）字段。它们用于定义接口相关的常量值，可以在其他类中访问，通常使用接口名称来访问。

// 定义一个接口
interface MyInterface {
    // 抽象方法（没有方法体）
    void abstractMethod();
    
    // 默认方法（带有方法体）
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
    
    // 静态方法（可以直接通过接口名称调用）
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
    
    // 常量（静态、final字段）
    int MY_CONSTANT = 42;
}

// 实现接口的类
class MyClass implements MyInterface {
    // 实现抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("This is the implementation of the abstract method.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建实现类对象
        MyClass obj = new MyClass();
        
        // 调用抽象方法
        obj.abstractMethod();
        
        // 调用默认方法
        obj.defaultMethod();
        
        // 调用静态方法（通过接口名调用）
        MyInterface.staticMethod();
        
        // 访问常量
        System.out.println("Constant value: " + MyInterface.MY_CONSTANT);
    }
}

• an interface can be used as a type
  type
  可以将接口用作引用类型，用来引用实现了该接口的任何类的对象。
  1. 多态性：在面向对象编程中，多态性允许不同类的对象被视为一个共同父类的对象。这个共同父类也可以是一个接口。当你将一个接口用作类型时，它允许不同类的对象以统一的方式处理，简化了代码并增加了灵活性。
  2. 接口作为引用类型：当你定义一个接口并创建一个引用变量时，你可以将实现了该接口的任何类的对象赋值给这个引用变量。这允许你访问接口中定义的方法，而不考虑具体类的实现。这是实现抽象和解耦的一种方式，使使用对象的代码与对象的实际实现相分离。

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪!");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myPet; // 将接口用作引用类型
        
        myPet = new Dog(); // 分配一个Dog对象
        myPet.makeSound(); // 调用Dog的makeSound方法
        
        myPet = new Cat(); // 分配一个Cat对象
        myPet.makeSound(); // 调用Cat的makeSound方法
    }
}
//在这个示例中，Animal 接口被用作变量 myPet 的引用类型。
//我们可以将Dog和Cat类的对象赋值给myPet，并调用myPet的makeSound方法，它将根据实际对象类型执行适当的方法。

(2) abstract class（抽象类）

• 抽象类也是一种抽象类型，可以包含抽象和非抽象方法，可以有构造方法和成员变量。
• 抽象类用 abstract 关键字声明，可以包含抽象方法（没有具体实现）和非抽象方法（有实现）。
• 类只可以继承一个抽象类，通过 extends 关键字继承，并实现其中的抽象方法。
• 可以有字段（成员变量）
• 抽象类用于建模一些通用行为，但可能有些行为需要子类来实现。
• 不可以被实例化（new）

abstract class Shape {
    abstract void draw(); // Abstract method
}

3. 作用

• control complexity
• forming modules / coponents that hide unimportant details and provide an intuitive interface to other components
• anabling more of the system to fit in our limited fleshy brains at once, without losing the key interactions.
• generalising capability（泛化能力）
• critical in all languages / paradigms

---

五. Java standard library

Java库：https://docs.oracle.com/en/java/javase/17/docs/api/index.html
Java标准库包括了大量的类、接口、方法和工具，涵盖了多个领域，，例如：

1. 基本工具类（java.lang）

提供了Java程序的基本功能，如字符串处理、基本数据类型、异常处理等。

2. 集合框架（java.util）

提供了实现常用数据结构（如列表、集合、队列、映射等）的类和接口，使数据的管理更加便捷和高效。

3. 输入输出（I/O）（java.io、java.nio）

提供了读写文件、网络操作、对象序列化等I/O操作相关的类和接口。

4. 多线程（java.lang.concurrent）

提供了线程管理和同步的工具和类，支持多线程编程。

5. 网络编程（java.net）

提供了网络通信相关的类和接口，支持网络应用的开发。

6. 数据库连接（JDBC - java.sql）

提供了访问数据库的接口和类，支持与数据库的交互。

7. 图形用户界面（Swing、AWT - java.awt、javax.swing）：

提供了创建图形用户界面的类和接口，支持窗口、组件、布局等GUI相关的操作。

8. 日期和时间处理（java.time）

提供了处理日期、时间和日历的类和接口。

这些组件和工具使得Java开发人员能够更高效、更容易地开发各种类型的应用程序，无需从头开始编写所有的代码。 Java标准库是Java平台的核心组成部分，为Java开发者提供了丰富的功能和一致的编程接口。

六. Java Naming

• case-sensitive 区分大小写
• consist with a,2,_,$ （字母、数字、下划线、$)
• 长度没有限制：理论上可以无限长，但实际上应保持合理和可读性。
• keywords and reserved words cannot be used

第一个字符：只能是字母、下划线或美元符号，不能是数字。

1. class: Start with capital letters.
2. Variable / field and method names: start with lower case, and upper case for subsequent words.
3. Constant names: all caps and underscores

七. Data type数据类型

1. Primitive data type 基本数据类型（直接存在栈内存中）

byte, short, int, long, float, double, boolean, char, string

Primitive data types and literals

2. 引用数据类型（存储对对象的引用——即内存地址）

（1）类class

（2）接口interface

（3）数组array

Arrays hold a fixed number of values of a given type (or sub-type) that can be accessed y an index.

// Declaring
int[] values;

// Initializing
values=new int[8];
values=new int[]{1,2,3,4};

（4）枚举enum

八. 优先级

从上往下，依次递减

九. Why Java?

important examples of:

• object-oriented programming
• large scale programming
• programming with a rich standard library

---