Java基础:面向对象编程(1)
1 Java中的类和对象
1.1 面向过程和面向对象
面向过程是流程化的,一步一步,上一步做完了,再做下一步。
面向对象是模块化的,我做我的,你做你的,我需要你做的话,我就告诉你一声。我不需要知道你到底怎么做,只看功劳不看苦劳。
不过,如果追到底的话,面向对象的底层其实还是面向过程,只不过把面向过程进行了抽象化,封装成了类,方便我们的调用。
1.2 类
1.2.1 类(Class)
- 定义:类是对象的蓝图或模板,定义了对象的属性和行为。
- 示例:
Person
类定义了一个人的基本属性和行为。
1.2.2 字段(Field)
- 定义:字段是类的成员变量,用于存储对象的状态。
- 示例:
Person
类中的name
、age
和sex
是字段,分别表示人的姓名、年龄和性别。 - 实例变量:字段也称为实例变量,因为它们在对象实例化后才会分配内存。
1.2.3 方法(Method)
- 定义:方法是类的行为,定义了对象可以执行的操作。
- 示例:
Person
类中的eat()
、sleep()
和dadoudou()
是方法,分别表示人可以吃饭、睡觉和打豆豆。
1.2.4 构造方法(Constructor)
- 定义:构造方法是用于创建和初始化对象的特殊方法。
- 示例:
Person
类中的public Person() {}
是默认的构造方法。 - 默认构造方法:如果类中没有显式定义构造方法,Java 会自动提供一个默认的无参构造方法。
1.2.5 代码示例
public class Person {
private String name;
private int age;
private int sex;
// 默认构造方法
public Person() {
}
// 自定义构造方法
public Person(String name, int age, int sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
private void eat() {
System.out.println(name + " is eating.");
}
private void sleep() {
System.out.println(name + " is sleeping.");
}
private void dadoudou() {
System.out.println(name + " is dadoudou.");
}
}
1.2.6 关键点总结
- 类:定义对象的蓝图。
- 字段:存储对象的状态,也称为实例变量。
- 方法:定义对象的行为。
- 构造方法:用于创建和初始化对象,如果没有显式定义,Java 会提供默认的无参构造方法。
1.2.7 进一步理解
- 封装:通过将字段设为
private
,并提供public
的getter
和setter
方法,可以实现数据的封装,隐藏内部实现细节。 - 继承:子类可以继承父类的字段和方法,并可以添加新的字段和方法。
- 多态:同一个方法可以在不同的对象中有不同的实现,增加了代码的灵活性和可扩展性。
1.3 new一个对象
1.3.1 创建 Java 对象
- 使用
new
关键字:在 Java 中,通过new
关键字来创建对象。例如:
这行代码通过Person person = new Person();
Person
类创建了一个Person
对象,并在堆内存中为其分配空间。
1.3.2 main()
方法
- 入口方法:
main()
方法是 Java 程序的入口点,程序从这里开始执行。 - 位置:
main()
方法可以放在当前类中,也可以放在另一个类中。
1.3.3 示例代码
1.3.3.1 第一种:main()
方法在 Person
类中
public class Person {
private String name;
private int age;
private int sex;
private void eat() {}
private void sleep() {}
private void dadoudou() {}
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); // 输出: null
System.out.println(person.age); // 输出: 0
System.out.println(person.sex); // 输出: 0
}
}
- 输出结果:
这是因为null 0 0
name
是String
类型,默认值为null
,而age
和sex
是int
类型,默认值为0
。
1.3.3.2 第二种:main()
方法在另一个类中
/**
* @author 微信搜「沉默王二」,回复关键字 PDF
*/
public class PersonTest {
public static void main(String[] args) {
Person person = new Person();
}
}
class Person {
private String name;
private int age;
private int sex;
private void eat() {}
private void sleep() {}
private void dadoudou() {}
}
- 实际开发中:通常会将
main()
方法放在一个单独的测试类中,而不是直接放在要测试的类中。这样可以保持类的单一职责,便于维护和测试。
1.3.4 关键点总结
- 创建对象:使用
new
关键字创建对象,并在堆内存中分配空间。 main()
方法:作为程序的入口点,可以放在当前类或另一个类中。- 实际开发:通常将
main()
方法放在一个单独的测试类中,便于管理和维护。
1.3.5 进一步理解
- 堆内存:对象在创建时会在堆内存中分配空间,堆内存是动态分配的,用于存储对象实例。
- 栈内存:方法调用和局部变量存储在栈内存中,栈内存是线程私有的,用于存储方法调用和局部变量。
- 默认值:类中的字段如果没有显式初始化,会有默认值。例如,
int
类型的默认值是0
,String
类型的默认值是null
。
1.4 初始化对象
1.4.1 对象初始化的三种方法
1.4.1.1 第一种:通过对象的引用变量
public class Person {
private String name;
private int age;
private int sex;
public static void main(String[] args) {
Person person = new Person();
person.name = "沉默王二";
person.age = 18;
person.sex = 1;
System.out.println(person.name); // 输出: 沉默王二
System.out.println(person.age); // 输出: 18
System.out.println(person.sex); // 输出: 1
}
}
- 直接赋值:通过对象的引用变量
person
直接对字段进行赋值。 - 优点:简单直观。
- 缺点:字段需要是
public
或protected
,破坏了封装性。
1.4.1.2 第二种:通过方法初始化
public class Person {
private String name;
private int age;
private int sex;
public void initialize(String n, int a, int s) {
name = n;
age = a;
sex = s;
}
public static void main(String[] args) {
Person person = new Person();
person.initialize("沉默王二", 18, 1);
System.out.println(person.name); // 输出: 沉默王二
System.out.println(person.age); // 输出: 18
System.out.println(person.sex); // 输出: 1
}
}
- 方法初始化:通过定义一个
initialize
方法来初始化字段。 - 优点:保持了字段的封装性,字段可以是
private
。 - 缺点:需要调用方法进行初始化,稍微复杂一些。
1.4.1.3 第三种:通过构造方法初始化
public class Person {
private String name;
private int age;
private int sex;
public Person(String name, int age, int sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public static void main(String[] args) {
Person person = new Person("沉默王二", 18, 1);
System.out.println(person.name); // 输出: 沉默王二
System.out.println(person.age); // 输出: 18
System.out.println(person.sex); // 输出: 1
}
}
- 构造方法初始化:在创建对象时通过构造方法传参进行初始化。
- 优点:最标准和推荐的做法,保持了封装性,且在对象创建时完成初始化。
- 缺点:需要定义构造方法,但通常这是最佳实践。
1.4.2 匿名对象
- 定义:匿名对象是没有引用变量的对象,只能在创建时使用一次。
- 示例:
new Person().initialize("沉默王二", 18, 1);
- 使用场景:适用于只需要使用一次的对象,不需要保存引用。
1.4.3 关键点总结
- 直接赋值:通过对象的引用变量直接对字段赋值,简单但破坏封装性。
- 方法初始化:通过定义方法来初始化字段,保持封装性,稍微复杂。
- 构造方法初始化:通过构造方法传参进行初始化,最标准和推荐的做法。
- 匿名对象:没有引用变量的对象,只能在创建时使用一次。
1.4.4 进一步理解
- 封装性:通过方法和构造方法初始化字段,可以保持字段的封装性,避免外部直接访问和修改字段。
- 构造方法重载:可以定义多个构造方法,提供不同的初始化方式,增加灵活性。
- 默认值:未初始化的字段会有默认值,例如
String
类型的默认值是null
,int
类型的默认值是0
。
1.5 关于Object
类
1.5.1 Object
类的方法
Object
类是所有 Java 类的最终父类,提供了一些基础的方法,这些方法可以分为以下几类:
1.5.1.1 对象比较
-
hashCode()
:返回对象的哈希码。public native int hashCode();
- 约定:相等的对象必须具有相等的哈希码。如果重写了
equals
方法,通常也应该重写hashCode
方法。 - 示例:
public int hashCode() { return Objects.hash(name, age); }
- 约定:相等的对象必须具有相等的哈希码。如果重写了
-
equals(Object obj)
:比较两个对象是否相等。public boolean equals(Object obj) { return (this == obj); }
- 重写:如果需要比较对象的值而不是内存地址,可以重写该方法。
- 示例:
class Person1 { private String name; private int age; public boolean equals(Object obj) { if (this == obj) { return true; } if (obj instanceof Person1) { Person1 p = (Person1) obj; return this.name.equals(p.getName()) && this.age == p.getAge(); } return false; } }
1.5.1.2 对象拷贝
clone()
:返回对象的一个副本。protected native Object clone() throws CloneNotSupportedException;
- 浅拷贝:默认实现只做浅拷贝。
- Cloneable 接口:类必须实现
Cloneable
接口,否则会抛出CloneNotSupportedException
异常。
1.5.1.3 对象转字符串
toString()
:返回对象的字符串表示。public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }
- 重写:通常会被重写以返回更有意义的信息。
- 示例:
public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; }
- IDE 生成:可以使用 IDE(如 IntelliJ IDEA)自动生成
toString
方法。 - Lombok:使用
@Data
注解自动生成toString
方法。
1.5.1.4 多线程调度
wait()
、notify()
、notifyAll()
:用于线程间的等待/通知机制。- 示例:
public class WaitNotifyDemo { public static void main(String[] args) { Object lock = new Object(); new Thread(() -> { synchronized (lock) { System.out.println("线程1:我要等待"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程1:我被唤醒了"); } }).start(); new Thread(() -> { synchronized (lock) { System.out.println("线程2:我要唤醒"); lock.notify(); System.out.println("线程2:我已经唤醒了"); } }).start(); } }
wait(long timeout)
:等待指定时间后自动唤醒。wait(long timeout, int nanos)
:更精确的等待时间。
- 示例:
1.5.1.5 反射
getClass()
:获取对象的类信息。public final native Class<?> getClass();
- 示例:
public class GetClassDemo { public static void main(String[] args) { Person p = new Person(); Class<? extends Person> aClass = p.getClass(); System.out.println(aClass.getName()); } }
- 示例:
1.5.1.6. 垃圾回收
finalize()
:在对象被垃圾回收前调用,用于清理资源。protected void finalize() throws Throwable { }
- 弃用:Java 9 开始已被弃用,不推荐使用。
1.5.2 关键点总结
- 对象比较:
hashCode()
和equals()
方法用于对象的比较。 - 对象拷贝:
clone()
方法用于对象的浅拷贝。 - 对象转字符串:
toString()
方法用于返回对象的字符串表示。 - 多线程调度:
wait()
、notify()
、notifyAll()
方法用于线程间的等待/通知机制。 - 反射:
getClass()
方法用于获取对象的类信息。 - 垃圾回收:
finalize()
方法在对象被垃圾回收前调用,已被弃用。
1.6 关于对象的一些小知识
1.6.1 面向对象编程的基本特征
1.6.1.1 万物皆对象
- 对象:状态(属性)+ 行为(方法)+ 标识(内存地址)。
- 消息传递:对象之间通过发送消息进行通信。
- 组合:通过组合多个对象来创建更复杂的对象。
- 实例化:对象是通过类实例化的。
- 接口一致性:同一类型的对象可以接收相同的消息。
1.6.1.2 对象具有接口
- 类:定义对象的类型,描述对象的特征和行为。
- 抽象数据类型:创建自定义的数据类型,操作对象(发送消息)。
- 接口:定义对象可以接收的请求。
- 实现:具体实现由类的方法完成。
1.6.1.3 访问权限修饰符
- API 提供者:类的创建者,提供接口。
- API 调用者:类的使用者,调用接口。
- 权限修饰符:
public
:公开访问。private
:私有访问,仅类内部可见。protected
:受保护访问,子类可见。- 默认(包级):同一包内可见。
- 作用:保护内部实现,便于修改和维护。
1.6.1.4 组合
- 复用:将已有类作为成员变量,组合成新类。
- 关系:has-a 关系。
1.6.1.5 继承
- 子类继承父类:子类拥有父类的
protected
和public
方法和字段。 - 扩展:子类可以添加新方法和字段。
- 重写:子类可以重写继承的方法。
- 关系:is-a 关系(仅重写)或 is-like-a 关系(扩展)。
1.6.1.6 多态
- 定义:同一方法在不同对象中有不同实现。
- 示例:
public class Shape { public void draw() { System.out.println("形状"); } } public class Circle extends Shape { @Override public void draw() { System.out.println("圆形"); } } public class Line extends Shape { @Override public void draw() { System.out.println("线"); } } public class Test { public static void main(String[] args) { Shape shape1 = new Line(); shape1.draw(); // 输出: 线 Shape shape2 = new Circle(); shape2.draw(); // 输出: 圆形 } }
- 解释:
shape1
和shape2
虽然是Shape
类型,但调用draw()
方法时,实际调用的是子类的实现,体现了多态性。
1.6.2 关键点总结
- 万物皆对象:对象是状态、行为和标识的组合。
- 对象具有接口:类定义对象的类型和接口。
- 访问权限修饰符:控制类的访问权限,保护内部实现。
- 组合:通过组合已有类创建新类,实现复用。
- 继承:子类继承父类,扩展和重写方法。
- 多态:同一方法在不同对象中有不同实现,增加灵活性。
1.6.3 进一步理解
- 抽象:面向对象编程的核心思想之一,通过抽象将复杂问题简化。
- 封装:通过访问权限修饰符和接口,隐藏内部实现细节,提高代码的可维护性。
- 继承与组合:继承用于类之间的层次关系,组合用于对象之间的组合关系,各有优劣。
- 多态:增加代码的灵活性和可扩展性,是面向对象编程的重要特性。
2 Java中的包
2.1 关于包
2.1.1 包的作用
- 解决命名冲突:通过包名来区分同名的类,避免命名冲突。
- 组织代码:将相关的类组织在一起,便于管理和维护。
2.1.2 包的声明
- 语法:在 Java 文件的第一行使用
package
关键字声明包名。package ming; // 声明包名 ming public class Person { }
- 完整类名:类的完整类名是
包名.类名
。例如,ming.Person
。
2.1.3 包的层次结构
- 多层结构:包名可以有多层结构,用
.
隔开。例如,java.util
。 - 没有父子关系:包之间没有继承关系。例如,
java.util
和java.util.zip
是不同的包。
2.1.4 包的组织
- 目录结构:Java 文件的目录结构应与包的层次结构一致。
package_sample └─ src ├─ hong │ └─ Person.java │ ming │ └─ Person.java └─ mr └─ jun └─ Arrays.java
- 编译后的目录结构:编译后的
.class
文件也需要按照包结构存放。package_sample └─ bin ├─ hong │ └─ Person.class │ ming │ └─ Person.class └─ mr └─ jun └─ Arrays.class
2.1.5 编译命令
- 命令行编译:在
src
目录下执行javac
命令,指定输出目录。javac -d ../bin ming/Person.java hong/Person.java mr/jun/Arrays.java
- IDE 自动编译:在 IDE 中,会自动根据包结构编译所有 Java 源码,无需手动执行编译命令。
2.1.6 关键点总结
- 解决命名冲突:通过包名区分同名类。
- 组织代码:将相关类组织在一起,便于管理和维护。
- 包的声明:在 Java 文件的第一行使用
package
关键字声明包名。 - 完整类名:类的完整类名是
包名.类名
。 - 包的层次结构:包名可以有多层结构,用
.
隔开。 - 目录结构:Java 文件和编译后的
.class
文件的目录结构应与包的层次结构一致。 - 编译命令:在命令行中使用
javac
命令编译 Java 文件,指定输出目录。
2.1.7 进一步理解
- 默认包:没有定义包名的类属于默认包,容易引起命名冲突,不推荐使用。
- 包的导入:使用
import
关键字导入其他包中的类,简化类名的使用。import ming.Person;
- 包的权限:包内的类默认具有包级访问权限,可以相互访问。
2.2 包的作用域
2.2.1 包的作用域
- 定义:在同一个包内的类可以访问包作用域的字段和方法。
- 修饰符:不用
public
、protected
、private
修饰的字段和方法就是包作用域。
2.2.2 示例代码
2.2.2.1 Person 类
package hello;
public class Person {
// 包作用域方法
void hello() {
System.out.println("Hello!");
}
}
- 包作用域方法:
hello()
方法没有使用public
、protected
、private
修饰符,因此它是包作用域的。
2.2.2.2 Main 类
package hello;
public class Main {
public static void main(String[] args) {
Person p = new Person();
p.hello(); // 可以调用,因为 Main 和 Person 在同一个包
}
}
- 访问包作用域方法:
Main
类和Person
类在同一个包hello
中,因此可以访问Person
类的包作用域方法hello()
。
2.2.3 关键点总结
- 包作用域:在同一个包内的类可以访问包作用域的字段和方法。
- 修饰符:不用
public
、protected
、private
修饰的字段和方法就是包作用域。 - 访问权限:包作用域的字段和方法只能在同一个包内访问。
2.2.4 进一步理解
- 默认访问权限:包作用域也称为默认访问权限(default access),在 Java 中,如果没有显式指定访问修饰符,默认就是包作用域。
- 包的组织:通过包的组织,可以将相关的类放在同一个包中,便于管理和访问。
- 访问控制:Java 提供了四种访问修饰符:
public
、protected
、private
和默认(包作用域),用于控制类的访问权限。public
:公开访问,任何类都可以访问。protected
:受保护访问,同一个包内的类和子类可以访问。private
:私有访问,仅类内部可见。- 默认(包作用域):同一个包内的类可以访问。
2.3 导入包
2.3.1 引用其他类的方法
在 Java 中,引用其他类有三种主要方法:
2.3.1.1 直接写出完整类名
// Person.java
package ming;
public class Person {
public void run() {
mr.jun.Arrays arrays = new mr.jun.Arrays();
}
}
- 优点:明确指出类的完整路径。
- 缺点:每次都要写完整的类名,比较繁琐。
2.3.1.2 使用 import
语句
// Person.java
package ming;
// 导入完整类名:
import mr.jun.Arrays;
public class Person {
public void run() {
Arrays arrays = new Arrays();
}
}
- 优点:简化类名的使用。
- 缺点:需要手动导入每个类。
2.3.1.3 使用 import
语句导入包中的所有类
// Person.java
package ming;
// 导入mr.jun包的所有class:
import mr.jun.*;
public class Person {
public void run() {
Arrays arrays = new Arrays();
}
}
- 优点:简化导入多个类。
- 缺点:难以看出类属于哪个包,不推荐使用。
2.3.2 import static
语法
package main;
// 导入System类的所有静态字段和静态方法:
import static java.lang.System.*;
public class Main {
public static void main(String[] args) {
// 相当于调用System.out.println(…)
out.println("Hello, world!");
}
}
- 优点:简化静态字段和方法的调用。
- 缺点:使用较少,容易引起混淆。
2.3.3 编译器查找类名的规则
- 完整类名:直接根据完整类名查找类。
- 简单类名:按以下顺序查找:
- 查找当前包是否存在这个类。
- 查找
import
的包是否包含这个类。 - 查找
java.lang
包是否包含这个类。
- 编译错误:如果按照上述规则无法确定类名,则编译报错。
2.3.4 示例代码
// Main.java
package test;
import java.text.Format;
public class Main {
public static void main(String[] args) {
java.util.List list; // ok,使用完整类名 -> java.util.List
Format format = null; // ok,使用import的类 -> java.text.Format
String s = "hi"; // ok,使用java.lang包的String -> java.lang.String
System.out.println(s); // ok,使用java.lang包的System -> java.lang.System
MessageFormat mf = null; // 编译错误:无法找到MessageFormat: MessageFormat cannot be resolved to a type
}
}
2.3.5 自动导入
- 默认自动导入:编译器会自动导入当前包的其他类和
java.lang.*
包。 - 手动导入:类似
java.lang.reflect
这样的包仍需要手动导入。
2.3.6 类名冲突
- 解决方法:如果有两个类名相同,例如
mr.jun.Arrays
和java.util.Arrays
,只能import
其中一个,另一个必须写完整类名。
2.3.7 关键点总结
- 直接写出完整类名:明确指出类的完整路径,但繁琐。
- 使用
import
语句:简化类名的使用,需要手动导入每个类。 - 使用
import
语句导入包中的所有类:简化导入多个类,但不推荐使用。 import static
语法:简化静态字段和方法的调用,使用较少。- 编译器查找类名的规则:优先使用完整类名,然后查找当前包、
import
的包和java.lang
包。 - 自动导入:编译器自动导入当前包的其他类和
java.lang.*
包。 - 类名冲突:如果有类名冲突,只能
import
其中一个,另一个必须写完整类名。
2.4 包的最佳实践
2.4.1 包名的命名规范
- 唯一性:为了避免名字冲突,推荐使用倒置的域名来确保包名的唯一性。
- 示例:
org.apache org.apache.commons.log com.tobebetterjavaer.sample
- 示例:
- 子包命名:子包可以根据功能自行命名,保持清晰和有意义。
2.4.2 避免命名冲突
- 避免与
java.lang
包的类重名:不要使用java.lang
包中的类名作为自己的类名。- 示例:
String System Runtime
- 示例:
- 避免与 JDK 常用类重名:不要使用 JDK 常用类的名字作为自己的类名。
- 示例:
java.util.List java.text.Format java.math.BigInteger
- 示例:
2.4.3 关键点总结
- 唯一性:使用倒置的域名来确保包名的唯一性。
- 子包命名:子包可以根据功能自行命名,保持清晰和有意义。
- 避免与
java.lang
包的类重名:不要使用java.lang
包中的类名作为自己的类名。 - 避免与 JDK 常用类重名:不要使用 JDK 常用类的名字作为自己的类名。
3 参考链接
- Object和类,万物皆对象
- package包