1.了解面向对象的三大特征

Java中面向对象的三大特征是封装、继承和多态。

封装
封装是面向对象编程的核心思想之一。它指的是将数据和方法包装在一个类中，并且对外部隐藏其内部的实现细节，只对外提供公共的访问方式。通过这种方式可以保障程序的安全性和可靠性。

在Java中，可以使用访问修饰符（public、protected、private）来控制类的成员变量和方法的访问权限。同时，也可以使用getter和setter等方法来访问私有成员变量。这样可以避免直接修改属性值造成的错误，提高程序的可维护性和可复用性。

继承
继承是面向对象编程的另一个核心思想。它指的是一个类可以派生出其他子类，并且子类可以继承父类的属性和方法。通过继承，可以避免重复编写相同的代码，提高程序的可维护性和可扩展性。

在Java中，可以使用extends关键字来继承一个类。子类可以访问父类中的公开成员变量和方法，并且可以添加自己的新成员变量和方法。同时，还可以使用super关键字来调用父类中的构造函数和方法。

多态
多态是面向对象编程的又一个核心思想。它指的是同一个类的对象可以表现出不同的形态，具有不同的行为和属性。通过多态，可以写出更加通用、灵活和可扩展的代码。

在Java中，多态分为静态多态和动态多态两种。其中，静态多态主要使用方法重载来实现，即定义多个同名但参数不同的方法。而动态多态则主要使用方法覆盖（重写）来实现，即子类重写父类的方法，并且通过父类类型变量引用子类对象来调用方法。

总之，在Java中，面向对象的三大特征是封装、继承和多态。这些特征使得Java程序更加灵活、通用和可扩展，同时也提高了程序的可维护性和可复用性。

2. 会定义类，会创建和使用对象

在Java中，定义类、创建对象和使用对象是面向对象编程的基本操作。下面分别介绍这三个方面。

1.定义类
在Java中，使用class关键字来定义一个类，语法格式如下：

访问修饰符 class 类名 {成员变量;构造函数;成员方法;
}

其中，访问修饰符可以是public、protected或private，用来控制类的访问权限；成员变量用来表示类的属性；构造函数用来初始化对象；成员方法用来表示类的行为。

例如，下面是一个简单的Person类的定义：

public class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public void sayHello() {System.out.println("Hello, my name is " + name + ", and I am " + age + " years old.");}
}

在上面的例子中，Person类包含两个私有成员变量name和age，一个公开的构造函数和一个公开的sayHello方法。

2.创建对象
在Java中，使用new关键字来创建一个对象，语法格式如下：

类名 对象名 = new 类名(构造函数参数);

其中，类名表示要创建的对象所属的类名；对象名表示要创建的对象的变量名；构造函数参数表示用于初始化对象的参数。

例如，下面是创建Person对象的示例：

Person p = new Person(“Tom”, 18);

在上面的例子中，使用new关键字创建了一个名为p的Person对象，并且使用构造函数初始化name和age属性。

3.使用对象
在Java中，可以通过对象名来访问对象的成员变量和成员方法。例如，下面是使用Person对象的示例：

p.sayHello();

在上面的例子中，使用对象名p调用了Person类中的sayHello方法。该方法会打印出“Hello, my name is Tom, and I am 18 years old.”这条消息。

需要注意的是，在访问成员变量时，需要使用点操作符（.）来访问对象的属性，如p.name表示访问p对象的name属性。而在调用成员方法时，也需要使用点操作符，如p.sayHello()表示调用p对象的sayHello方法。

总之，在Java中，定义类、创建对象和使用对象是面向对象编程的基本操作。定义类使用class关键字，创建对象使用new关键字，使用对象可以通过对应的对象名来访问成员变量和成员方法。

3.会定义和使用局部变量与成员变量

在Java中，局部变量和成员变量都是用来存储数据的变量。它们有一些区别，在定义和使用时需要注意。

1.定义局部变量
局部变量定义在方法、代码块或构造函数内部，只能在其所在的作用域内被访问。在定义局部变量时，必须指定其类型，并且可以给它赋初值。例如：

public void exampleMethod() {int num = 10; // 定义一个int类型的局部变量num，并初始化为10String str; // 定义一个String类型的局部变量strstr = "Hello"; // 给局部变量str赋值
}

在上面的例子中，定义了一个int类型的局部变量num并初始化为10，还定义了一个String类型的局部变量str，并且在后面赋值。

2.使用局部变量
局部变量只能在其所在的作用域内被访问，一旦作用域结束就会被销毁。在方法、代码块或构造函数内部，可以直接引用该变量。例如：

public void exampleMethod() {int num = 10;if (num > 0) {String str = "Positive"; // 定义一个String类型的局部变量strSystem.out.println(str); // 输出"Positive"}System.out.println(num); // 输出10
}

在上面的例子中，定义了一个int类型的局部变量num，并且在if语句块内定义了一个String类型的局部变量str。因为作用域不同，所以在if语句块外部不能访问局部变量str。

3.定义成员变量
成员变量定义在类里面，可以被类中所有方法和代码块访问。在定义成员变量时，必须指定其类型，并且可以给它赋初值。例如：

public class Example {int num = 10; // 定义一个int类型的成员变量num，并初始化为10String str; // 定义一个String类型的成员变量str
}

在上面的例子中，定义了一个int类型的成员变量num并初始化为10，还定义了一个String类型的成员变量str。

4.使用成员变量
成员变量可以被类中所有方法和代码块访问。在方法、代码块或构造函数内部，可以使用this关键字来引用该变量。例如：

public class Example {int num = 10;String str;public void setStr(String str) {this.str = str; // 使用this关键字引用成员变量str}public void printNum() {System.out.println(num); // 直接引用成员变量num}
}

在上面的例子中，定义了一个setStr方法和一个printNum方法。在setStr方法中，使用this关键字引用成员变量str。在printNum方法中，直接引用成员变量num。

总之，在Java中，局部变量和成员变量都可以用来存储数据，但是它们有区别。局部变量定义在方法、代码块或构造函数内部，只能在其所在的作用域内被访问；成员变量定义在类里面，可以被类中所有方法和代码块访问。在使用时也需要注意这些区别。

4.会定义和使用类的构造方法及重载

ava中的构造方法是一种特殊的方法，用于创建和初始化类的对象。它们与类具有相同的名称，但没有返回类型，并且在使用new关键字创建对象时被自动调用。

以下是定义和使用Java类的构造方法及其重载的示例：

public class MyClass {private int x;private String y;// 无参构造方法public MyClass() {x = 0;y = "";}// 带两个参数的构造方法public MyClass(int x, String y) {this.x = x;this.y = y;}// 带一个参数的构造方法public MyClass(int x) {this(x, "");}// getter 和 setter 方法省略}

在上面的示例中，我们定义了一个名为MyClass的类，并包括三个不同的构造方法：一个没有参数，一个带两个参数，以及一个带一个参数。

当使用new MyClass()创建对象时，将调用无参构造函数，并将x设置为0，y设置为空字符串。当使用new MyClass(10, “hello”)创建对象时，将调用带两个参数的构造方法，并将x设置为10，y设置为"hello"。当使用new MyClass(5)创建对象时，将调用带一个参数的构造方法，并将x设置为5，y设置为空字符串。

可以看到，通过定义不同的构造方法来接受不同的参数组合，我们可以轻松地创建各种不同类型的对象。

Java中的重载（Overloading）指的是在同一个类中，可以定义多个同名但参数列表不同的方法。这些方法可以有不同的返回类型，但不能只有返回类型不同而其他都相同。

当调用一个被重载的方法时，编译器会根据传入参数的数量、类型和顺序，自动匹配调用对应的重载方法。这样可以使代码更加灵活，方便使用。
ava中的构造方法也可以进行重载，就像其他方法一样。构造方法的重载与普通方法的重载相似，只是构造方法没有返回类型。

在同一个类中，可以定义多个参数列表不同的构造方法，这些构造方法可以有不同的访问修饰符和参数列表。当创建新对象时，编译器会根据传入参数的数量、类型和顺序自动匹配调用对应的构造方法。这样可以使对象的创建更加灵活。

public class Person {private String name;private int age;// 无参构造方法public Person() {name = "Unknown";age = 0;}// 带参数的构造方法，重载了上面的无参构造方法public Person(String n, int a) {name = n;age = a;}// getter 和 setter 方法public String getName() {return name;}public void setName(String n) {name = n;}public int getAge() {return age;}public void setAge(int a) {age = a;}
}

在这个例子中，Person 类有两个构造方法：一个无参构造方法和一个带有两个参数的构造方法。这两个方法都可以用来创建 Person 类的对象，但它们的参数列表不同。第一个构造方法将名字和年龄设置为默认值；第二个构造方法根据传入的参数设置名字和年龄。通过使用不同的构造方法，我们可以以不同的方式创建 Person 对象。

会声明包、导入包

Java中的包（Package）是一种组织代码的机制，它可以将相关的类、接口和其他资源组合在一起。在声明一个Java包时，我们需要在Java源文件的开头添加 package 语句。

例如：

package com.example.mypackage;

这个例子中，声明了一个名为 com.example.mypackage 的包。

要使用另一个包中的类或接口，我们需要导入该包。在Java中，有三种方式可以导入包：

1.显示导入：使用 import 语句显式地导入指定的类或接口。

import com.example.anotherpackage.AnotherClass;

2.隐式导入：Java会自动导入 java.lang 包中的所有类和接口。

3.静态导入：通过使用 import static 语句导入指定类或接口中的静态成员。

import static java.lang.Math.PI;

这些方式都可以帮助我们更好地组织和管理Java代码。

6.会使用private关键字，能对类实现封装

在Java中，private 关键字用于声明私有成员。被声明为 private 的成员变量和方法只能在当前类内部访问，无法在其他类中直接使用。

通过使用 private 关键字，我们可以实现对类的封装（Encapsulation）。类的封装是一种数据隐藏的技术，它可以将一个类的实现细节隐藏起来，从而使类更加安全和灵活。

下面是一个简单的例子，演示了如何使用 private 关键字实现类的封装：

public class Person {private String name;private int age;public String getName() {return name;}public void setName(String n) {name = n;}public int getAge() {return age;}public void setAge(int a) {if (a >= 0 && a <= 120) {age = a;} else {System.out.println("Invalid age!");}}
}

在这个例子中，Person 类有两个私有成员变量 name 和 age，它们只能在 Person 类内部访问。为了让其他类访问这些成员变量，我们提供了公共的 getter 和 setter 方法。同时，在 setAge() 方法中，我们添加了一些额外的逻辑，用于检查年龄是否合法。通过这种方式，我们可以保证 Person 对象的安全性和完整性，并且可以更好地控制类的实现细节。

7.会使用this关键字

在Java中，this 关键字是一个引用，它指向当前对象。可以将 this 看作是当前对象的一个别名，使用 this 可以访问当前对象的成员变量和方法。

以下是 this 关键字的常见用途：

1.区分局部变量和成员变量：在构造方法或其他方法中，如果局部变量名与成员变量名相同，则可以使用 this 关键字来区分它们。

public class Person {private String name;private int age;public Person(String name, int age) {this.name = name; // 使用 this 来引用成员变量this.age = age;}
}

2.在方法中返回当前对象：在方法中使用 return this; 可以返回当前对象的引用，允许方法链式调用。

public class Calculator {private int result;public Calculator add(int num) {result += num;return this; // 返回当前对象的引用，允许方法链式调用}public Calculator sub(int num) {result -= num;return this;}public int getResult() {return result;}
}// 示例代码
Calculator calculator = new Calculator();
int result = calculator.add(5).sub(3).getResult(); // 等价于 (0 + 5) - 3
System.out.println(result); // 输出结果为 2

3.传递当前对象给其他方法：当需要将当前对象作为参数传递给其他方法时，可以使用 this 关键字。

public class Person {private String name;private int age;public void sayHello() {System.out.println("Hello, my name is " + name + ", I am " + age + " years old.");}public void introduce(MyInterface obj) { // 将当前对象作为参数传递给其他方法obj.printInfo(this); // 调用其他方法，并传入当前对象}
}public interface MyInterface {void printInfo(Person person);
}// 示例代码
Person person = new Person("Tom", 18);
person.introduce(new MyInterface() {@Overridepublic void printInfo(Person person) {person.sayHello(); // 调用 Person 类的 sayHello 方法}
});

8.会使用static关键字

在Java中，static 关键字用于表示静态成员。有两种类型的静态成员：静态变量和静态方法。

1.静态变量：被声明为 static 的变量称为静态变量，它们属于类而不是对象。静态变量只需要在第一次使用它时初始化，并且可以被所有类的实例共享。通常，静态变量用于存储与类相关的常量或计数器。

public class Counter {private static int count; // 静态变量public Counter() {count++;}public static int getCount() { // 静态方法return count;}
}// 示例代码
Counter counter1 = new Counter();
Counter counter2 = new Counter();
Counter counter3 = new Counter();
System.out.println(Counter.getCount()); // 输出结果为 3

2.静态方法：被声明为 static 的方法称为静态方法，它们也属于类而不是对象。静态方法不能访问非静态成员，但可以通过类名直接调用。通常，静态方法用于提供与类相关的实用程序方法。

public class MathUtils {public static double circleArea(double radius) { // 计算圆形面积的静态方法return Math.PI * radius * radius;}
}// 示例代码
double area = MathUtils.circleArea(5.0); // 直接通过类名调用静态方法
System.out.println(area); // 输出结果为 78.53981633974483

以上是 static 关键字的常见用途。需要注意的是，静态成员不能被实例化对象所访问，而应该使用类名来访问它们。