面向对象编程
Java是一种面向对象的编程语言。面向对象编程，英文是Object-Oriented Programming，简称OOP。
那什么是面向对象编程？
和面向对象编程不同的，是面向过程编程。面向过程编程，是把模型分解成一步一步的过程。比如，老板告诉你，要编写一个TODO任务，必须按照以下步骤一步一步来：
- 读取文件；
- 编写TODO；
- 保存文件。
而面向对象编程，顾名思义，你得首先有个对象：有了对象后，就可以和对象进行互动：
GirlFriend gf = new GirlFriend();
gf.name = "Alice";
gf.send("flowers");
因此，面向对象编程，是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。
在本章中，我们将讨论：
面向对象的基本概念，包括：
- 类
- 实例
- 方法
面向对象的实现方式，包括：
- 继承
- 多态
Java语言本身提供的机制，包括：
- package
- classpath
- jar
以及Java标准库提供的核心类，包括：
- 字符串
- 包装类型
- JavaBean
- 枚举
- 常用工具类
内存分析
面对对象基础
- 核心思想：抽象！
- 三大特性：
- 封装
- 继承
- 多态
类与对象
类 是一个模板 ，对象是一个具体的实例
-
Class 类
-
instance 对象实例
定义了class，只是定义了对象模版，而要根据对象模版创建出真正的对象实例，必须用new操作符。
new操作符可以创建一个实例，然后，我们需要定义一个引用类型的变量来指向这个实例：
Person ming = new Person();上述代码创建了一个Person类型的实例，并通过变量
ming指向它。注意区分
Person ming是定义Person类型的变量ming，而new Person()是创建Person实例。有了指向这个实例的变量，我们就可以通过这个变量来操作实例。访问实例变量可以用
变量.字段ming.name = "Xiao Ming"; // 对字段name赋值 ming.age = 12; // 对字段age赋值 System.out.println(ming.name); // 访问字段name Person hong = new Person(); hong.name = "Xiao Hong"; hong.age = 15;
###对象的引用
引用类型 八大基本类型
对象是通过引用来操作的:栈—>堆(地址)(c语言的指针)
###属性
Field字段 -----成员变量
默认初始化值：
数字 0 0.0
char: u0000
boolean: false
其他(引用类型):null
方法
一个class可以包含多个field，但是，直接把field用public暴露给外部可能会破坏封装性。显然，直接操作field，容易造成逻辑混乱。为了避免外部代码直接去访问field，我们可以用private修饰field，拒绝外部访问。
用方法(method)来让外部代码可以间接修改field
public class Main {
public static void main(String[] args) {
Person ming = new Person();
ming.setName("Xiao Ming"); // 设置name
ming.setAge(12); // 设置age
System.out.println(ming.getName() + ", " + ming.getAge());
}
}
class Person {
private String name;
private int age;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return this.age;
}
public void setAge(int age) {
if (age < 0 || age > 100) {
throw new IllegalArgumentException("invalid age value");
}
this.age = age;
}
}
通过这种方法可以对输入的变量进行检查例如，不允许传入null和空字符串：
public void setName(String name) {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("invalid name");
}
this.name = name.strip(); // 去掉首尾空格
}
public void setName(String name) {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("invalid name");
}
this.name = name.strip(); // 去掉首尾空格
}
-
定义方法
修饰符 方法返回类型 方法名(方法参数列表) { 若干方法语句; return 方法返回值; }如果没有返回值可设置void以此省略return 0;
-
private方法
不允许外部调用，内部方法可以调用。例如：
public class Main { public static void main(String[] args) { Person ming = new Person(); ming.setBirth(2008); System.out.println(ming.getAge()); } } class Person { private String name; private int birth; public void setBirth(int birth) { this.birth = birth; } public int getAge() { return calcAge(2019); // 调用private方法 } // private方法: private int calcAge(int currentYear) { return currentYear - this.birth; } } -
this变量
在方法内部，可以使用一个隐含的变量
this，它始终指向当前实例。因此，通过this.field就可以访问当前实例的字段。如果没有命名冲突，可以省略
this。但是，如果有局部变量和字段重名，那么局部变量优先级更高，就必须加上this -
方法参数
方法可以包含0或多个参数，且传递变量时严格按照定义一一传递。
-
可变参数
可变参数用
类型...或者String[]定义，可变参数相当于数组类型：class Group { private String[] names; public void setNames(String... names) { this.names = names; } }但是，调用方需要自己先构造
String[]，比较麻烦。例如：Group g = new Group(); g.setNames(new String[] {"Xiao Ming", "Xiao Hong", "Xiao Jun"}); // 传入1个String[]可变参数可以保证无法传入
null，因为传入0个参数时，接收到的实际值是一个空数组而不是null。 -
参数绑定
调用方把参数传递给实例方法时，调用时传递的值会按参数位置一一绑定。
传递后改变原参数不影响实例方法
构造方法
创建实例的时候，我们经常需要同时初始化这个实例的字段，例如：
Person ming = new Person();
ming.setName("小明");
ming.setAge(12);
但！我们可以！用构造方法精简代码！
能在创建Person实例的时候，一次性传入name和age，完成初始化：
public class Main {
public static void main(String[] args) {
Person p = new Person("Xiao Ming", 15);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
由于构造方法是如此特殊，所以构造方法的名称就是类名。构造方法的参数没有限制，在方法内部，也可以编写任意语句。但是，和普通方法相比，构造方法没有返回值（也没有void），调用构造方法，必须用new操作符。
-
默认构造方法
如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句
如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法:
public class Main { public static void main(String[] args) { Person p = new Person(); // 编译错误:找不到这个构造方法 } } class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return this.name; } public int getAge() { return this.age; } }如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来
没有在构造方法中初始化字段时，引用类型的字段默认是
null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false可以定义多个构造方法，在通过
new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分
封装
追求“高内聚，低耦合”。类的内部数据细节自己完成，不允许外部干涉，仅暴露少量方法给外部使用！
通常，应禁止访问一个对象中数据的实际表示，通过操作接口来访问，称为信息隐藏
属性私有(private)
运用get/set方法来访问
可以通过set方法来验证数据合法性！
优点
1.提高系统安全性，保护数据
2.隐藏代码的实现细节
3.统一接口！
4.系统可维护性增加了
方法重载
方法名相同，但输入的数据类型不同
按照输入的数据类型选用对应方法
(get/set少用，构造器居多)
###继承
-
本质是对类的抽象
-
Java中只有单继承，没有多继承(父亲可以有很多儿子)(C++有多继承)
-
子类继承父类用extends表示
-
private/final属性不会被继承！
-
子类的修饰符范围至少要比父类大
-
子类可以调用父类中的所有方法
-
Object为最牛逼的父类(所有类都继承Object)
super/this
super:调用父类的对象
this:调用当前类的对象
- super调用父类的构造方法，必须在构造方法第一个
- super必须只能出现在子类的方法或构造方法中
- super和this不能同时调用构造方法
Vs this:
-
代表的对象不同
this:调用者这个对象本身
super:代表父类对象的应用
-
前提
this:没有继承也可以使用
super:只能在继承条件下才能使用
-
构造方法
this():本类的构造
super():父类的构造
private<protected<default<public
方法重写
无法被重写的方法
- static方法，属于类，不属于实例；
- final 常量；
- private方法；
重写都是方法的重写
与属性无关
static静态方法与类一起加载无法进行重写
重写必须要有继承关系
子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符的范围可以扩大
- 抛出的异常：范围可以缩小，但不能扩大
多态
-
同一方法可以根据发送对象的不同二采用多重不同的行为方式
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
-
存在条件
有继承关系
子类重写父类方法
父类引用指向子类对象
-
多态是方法的多态，属性没有多态性
-
父类和子类要有联系 否则 类型转化异常 ClassCastException
- 子类能调用的方法都是自己的或者继承父类的
- 父类可以指向子类，但是不能调用子类独有的方法（但父类可以强制转化为子类来调用）
- 对象能执行哪些方法，主要看对象左边的类型
instanceof
对象的强制转化
类型之间的强制转化：
父------->子
父类转化为子类可以调用子类独有的方法
子类转化为父类可能会丢失自己原有的方法
-
子转父: 向上转型,直接转化,丢失子类中原本可直接调用的特有方法；
-
父转子:向下转型,强制转化,会丢失父类被子类所重写掉的方法。
强制转化可以方便方法的调用，减少重复的代码
static关键字详解
静态变量(成员变量)尽量用 类名.变量名 访问
类名.变量名
静态方法尽量用 类名.方法名 访问(在该类下可以之间用方法名访问)
类名.方法名
静态代码块
static{
//静态代码块
//类加载时加载
//最先执行且只执行一次
}
静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
抽象类(abstract)
类的单继承，借口的多实现
抽象类中可以写普通方法
抽象方法只含有方法名，不含有具体做法
抽象方法必须在抽象类中
抽象类的所有方法必须由子类实现
继承了抽象类的子类都必须实现它的方法重写
除非你tmd子类也是抽象类(子子类给👴去实现)
特点
- 不能new抽象类，只能靠子类去实现，去约束！
接口！
普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)都有
接口：只有规范！(写nm方法)
接口就是规范！接口的本质是契约，是OO(面向对象)的精髓？！(对对象的抽象)
接口声明的关键字是interface(不是class啊喂)
接口中定义的所有量都是全局静态常量(public static final)(少用)
接口中定义的所有方法都是抽象的(public abstract)
接口都需要实现类(命名规则：原名称+Impl) implements 接口1,接口2，······)
实现了接口的类，就必须重写接口中的所有(抽象)方法
可以运用接口实现多继承
作用
- 约束
- 定义方法，让其他人帮忙实现(给了个规范)(面向接口编程)
- 所有方法都是public abstract
- 所有常量都是public static final
- 接口不能被直接实例化,因为接口中没有构造方法
- implements关键字可以实现多个接口
- 必须要重写接口中的方法
内部类（不要求）
内部类就是在一个类的内部再定义一个类
分为：
-
成员内部类
-
静态内部类
-
局部内部类
-
匿名内部类
-
成员内部类
要先实例化外部类
通过外部类来实例化内部类(外部类.内部类)(外部类.new)
内部类可以直接访问外部类的私有属性/方法
- 静态内部类
无法访问非静态内部属性
- 局部内部类
外部类的方法中的类
- 匿名内部类
没有名字来初始化类
new Apple().eat()
ce(不是class啊喂)
接口中定义的所有量都是全局静态常量(public static final)(少用)
接口中定义的所有方法都是抽象的(public abstract)
接口都需要实现类(命名规则：原名称+Impl) implements 接口1,接口2，······)
实现了接口的类，就必须重写接口中的所有(抽象)方法
可以运用接口实现多继承
作用
- 约束
- 定义方法，让其他人帮忙实现(给了个规范)(面向接口编程)
- 所有方法都是public abstract
- 所有常量都是public static final
- 接口不能被直接实例化,因为接口中没有构造方法
- implements关键字可以实现多个接口
- 必须要重写接口中的方法
扫一扫
918
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
