Java1

1.基本结构

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

• public class HelloWorld:定义一个名为 HelloWorld 的公共类。
• public static void main(string[] args):主方法，程序入口。
• System.out.println("HelloWorld!");: 输出语句。

2.数据类型

基本类型：

• 整数类型:byte,short,int,long (int age=25;)
• 浮点类型:float,double (double salary=50000.50;)
• 字符类型:char (char grade='A';)
• 布尔类型:boolean (boolean isJavaFun=ture;)

引用类型

• 类：如String （String name="johnny";)
• 数组：如int[] (int[] a=new int[8];或者int[] a; a=new int[8];)(数组的初始化：int[] a={1,2};)
• 接口

3.类和对象：

类:是共同特征的描述(设计图); 对象:是真实存在的具体实例。

类的声明语法

得到对象：

[修饰符]class 类{
// 成员变量（代表属性，一般是名词） 
// 构造方法
// 成员方法（代表行为，一般是动词）
}

• 修饰符：（class前的修饰符可以有多个）

  • public：存取控制符，表明此类是公有类。
  • private、protected：访问修饰符，控制类的可见性。
  • abstract：抽象类，不能被实例化。
  • final：终结类，不能被继承的类。

• 成员变量定义格式：修饰符 数据类型 变量名称 = 初始化值（一般无需指定初始化值）

对象的声明和引用

• 对象声明的基本语法：类名 对象名 = new 类名(构造参数);
• 对象的引用：对象.成员变量;或者对象.成员方法（...）;

4.import语句：

在 Java 中，import 语句用于引入其他类、接口或包，以便在当前文件中使用它们。通过 import，你可以访问其他 Java 文件中的公共类或接口，而不需要使用完整的类名（包括包名）。这使得代码更加简洁和易于阅读。import 语句必须放在 Java 文件的顶部，类声明之前。

基本语法：

例 import java.util.Scanner;

5.Scanner类

Scanner 类是 Java 中用于获取用户输入的一个非常实用的工具。它位于 java.util 包中，能够从多种输入源（如键盘、文件等）读取数据。以下是 Scanner 类的一些主要特性和用法：

（1. 导入 Scanner 类

在使用 Scanner 类之前，需要先导入它：

import java.util.Scanner;

（2. 创建 Scanner 对象

通常，我们会创建一个 Scanner 对象来读取输入。以下是从控制台读取输入的示例：

Scanner scanner = new Scanner(System.in);

（3. 读取不同类型的数据

Scanner 类提供了多种方法来读取不同类型的数据，包括：

• nextInt()：读取一个整数
• nextDouble()：读取一个双精度浮点数
• nextLine()：读取一行文本
• next()：读取一个单词（以空格为分隔符）

（4.关闭Scanner

使用完 Scanner 后，应该调用 close() 方法来释放资源。 (scanner.close(); // 关闭 Scanner)

6.this

（1. this 的本质

• this 是一个引用，指向当前正在调用方法或构造方法的对象。
• 它只能在实例方法或构造方法中使用，不能在静态方法（static 方法）中使用，因为静态方法属于类，而不是对象。

（2. this 的作用

this 的主要作用是帮助我们在代码中明确区分：

• 成员变量（类的属性）和局部变量（方法中的变量）。
• 当前对象的其他构造方法（通过 this() 调用）。

（3. this 的使用场景

（1）区分成员变量和局部变量

当成员变量和局部变量同名时，用 this 明确指代成员变量。

public class Dog {
    private String name;  // 成员变量

    public void setName(String name) {  // 局部变量
        this.name = name;  // this.name 指成员变量，name 指局部变量
    }
}

（2）调用当前类的其他构造方法

在构造方法中，用 this() 调用当前类的其他构造方法。

public class Dog {
    private String name;
    private int age;

    public Dog() {
        this("无名", 0);  // 调用带参构造方法
    }

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

（3）返回当前对象

在方法中返回当前对象，用于链式调用。

public Dog setName(String name) {
    this.name = name;
    return this;  // 返回当前对象
}

（4）作为参数传递

将当前对象作为参数传递给其他方法。

public void print() {
    printName(this);  // 将当前对象作为参数传递
}

（5）在内部类中访问外部类对象

在内部类中，用 外部类名.this 访问外部类对象。

public class Outer {
    private String name = "外部类";

    public class Inner {
        public void print() {
            System.out.println(Outer.this.name);  // 访问外部类的成员变量
        }
    }
}

7.构造方法

构造方法（Constructor）是 Java 中用于创建和初始化对象的特殊方法。它在对象被创建时自动调用，通常用于设置对象的初始状态。以下是关于构造方法的详细说明：

---

（1. 构造方法的特点

• 名字必须与类名完全相同。
• 没有返回类型，连 void 也不能写。
• 在创建对象时自动调用，不能手动调用。
• 一个类可以有多个构造方法（通过重载实现）。
• 如果没有显式定义构造方法，Java 会提供一个默认的无参构造方法。

---

（2. 构造方法的语法

public class 类名 {
    // 无参构造方法
    public 类名() {
        // 初始化代码
    }

    // 带参构造方法
    public 类名(参数列表) {
        // 初始化代码
    }
}

---

（3. 构造方法的作用

• 用于创建对象。
• 初始化对象的属性（成员变量）。
• 可以在构造方法中执行一些必要的逻辑操作。

8.方法重载

方法重载（Method Overloading）是 Java 中的一种特性，它允许在同一个类中定义多个同名方法，但这些方法的参数列表必须不同。方法重载的目的是让方法的功能更加灵活，能够处理不同类型的输入。

---

 方法重载的规则

• 方法名必须相同。
• 参数列表必须不同（参数的类型、数量或顺序不同）。
• 返回类型可以相同也可以不同，但仅返回类型不同不足以构成重载。
• 重载方法可以有不同的访问修饰符（如 public、private 等）。
• 重载方法可以抛出不同的异常。

生活中的例子

想象你有一个多功能咖啡机：

1. 如果你只放咖啡粉，它会做一杯普通咖啡。
2. 如果你放咖啡粉和牛奶，它会做一杯拿铁。
3. 如果你放咖啡粉、牛奶和糖，它会做一杯甜拿铁。

这里的 “做咖啡”就是一个重载的方法：

• 参数不同（咖啡粉、咖啡粉+牛奶、咖啡粉+牛奶+糖），结果也不同。

9.数据成员

数据成员（Data Members）是类中的变量，用于存储对象的状态或属性。它们是类的核心组成部分，定义了对象的特征。下面我用简单易懂的方式解释数据成员，并结合示例帮助你理解。

---

（1. 什么是数据成员？

数据成员是类中定义的变量，用来表示对象的属性或状态。比如：

• 一个 Dog 类可以有数据成员 name（名字）、age（年龄）、color（颜色）等。
• 一个 Car 类可以有数据成员 brand（品牌）、speed（速度）、price（价格）等。

---

（2. 数据成员的分类

数据成员可以分为两类：

1. 实例变量（Instance Variables） ：

   • 属于对象，每个对象都有自己的一份实例变量。
   • 不同对象的实例变量值可以不同。
   • 在对象创建时分配内存，对象销毁时释放内存。

2. 静态变量（Static Variables） ：

   • 属于类，所有对象共享同一份静态变量。
   • 在类加载时分配内存，程序结束时释放内存。
   • 用 static 关键字修饰。

（3. 数据成员的初始化

• 如果没有显式初始化，数据成员会有默认值：

  • 数值类型（如 int、double）：0 或 0.0。
  • 布尔类型（boolean）：false。
  • 引用类型（如 String、Object）：null。

• 可以在声明时直接初始化，也可以在构造方法中初始化。

10.toString和equals方法

11.异常处理

错误的分类

• 错误Error：致命性，不能简单的恢复执行。
• 异常Exception：非致命性，通过某种修正后程序还能继续执行。

异常的处理

• 声明抛出异常throw：不在当前方法内处理异常，而是把异常抛出到调用当前方法的方法中。
• 捕获异常catch：在当前方法中使用catch语句捕获所发生的异常，并进行相应的处理。

异常处理的语法

（1）try-catch 块

try {
    // 可能抛出异常的代码
} catch (异常类型 变量名) {
    // 处理异常
}

示例：

try {
    int result = 10 / 0;  // 抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("捕获到异常: " + e.getMessage());
}

输出：

捕获到异常: / by zero

---

（2）try-catch-finally 块

try {
    // 可能抛出异常的代码
} catch (异常类型 变量名) {
    // 处理异常
} finally {
    // 无论是否发生异常，都会执行的代码
}

示例：

try {
    int result = 10 / 0;  // 抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("捕获到异常: " + e.getMessage());
} finally {
    System.out.println("finally 块执行了");
}

输出：

捕获到异常: / by zero
finally 块执行了

---

（3）throw 关键字

用于手动抛出异常。

示例：

public void checkAge(int age) {
    if (age < 18) {
        throw new ArithmeticException("年龄不足 18 岁");
    } else {
        System.out.println("年龄合法");
    }
}

使用：

checkAge(15);  // 抛出异常

输出：

Exception in thread "main" java.lang.ArithmeticException: 年龄不足 18 岁

---

（4）throws 关键字

用于声明方法可能抛出的异常。

示例：

public void readFile(String path) throws FileNotFoundException {
    File file = new File(path);
    FileInputStream stream = new FileInputStream(file);  // 可能抛出 FileNotFoundException
}

调用时需要使用 try-catch 处理：

try {
    readFile("test.txt");
} catch (FileNotFoundException e) {
    System.out.println("文件未找到: " + e.getMessage());
}