面向对象-1
面向->找；对象->东西
面向对象编程就是找东西来编程
面向对象的三大基本特征：封装、继承、多态
- 面向对象(Object Oriented)：强调解决问题的主体，强调谁来解决这个问题，强调的是数据，强调的是对象，强调的是谁拥有数据和操作数据的权力。
- 在java中，必须先设计类，才能获得对象
- 类（设计图）:是对象共同特征的描述;
- 对象:真实存在的具体实例，事物的具体体现
1.定义类
//定义类
public class 类名{
1、成员变量（代表属性，一般是名词）
2、成员方法（代表行为，一般是动词）
3、构造器
4、代码块
5、内部类
}
//得到类的对象
类名 对象名 = new 类名();
//对象的使用
对象名.成员变量
对象名.成员方法
成员变量的完美定义格式是 修饰符 数据类型 变量名称 = 初始化值 一般无需指定初始化值，存在默认值
public class Car {
//属性（成员变量）
String name;
double price;
//行为
public void start() {
System.out.println(name + "车启动了");
}
public void run() {
System.out.println(name + "车开得很快");
}
public void message(){
System.out.println(name + "车价格为" + price);
}
}
public class Test {
public static void main(String[] args) {
//自己设计对象并使用
//类名 对象名 = new 类名();
Car c = new Car();
c.message();
c.name = "奔驰";
c.price = 100;
c.start();
c.run();
}
}
运行结果
注意事项
- 类名不能用关键字
- 一个代码文件中可以定义多个类，但是只能一个类是public修饰的，public修饰的类名必须是Java代码的文件名称
- 类中可以定义的五大成分:成员变量Field，成员方法Method，构造器Constructor，内部类，代码块
2.对象内存图
public class Test {
public static void main(String[] args) {
//自己设计对象并使用
//类名 对象名 = new 类名();
Car c = new Car();
c.name = "奔驰";
c.price = 100;
c.message();
Car c0 = new Car();
c0.name = "宝马";
c0.price = 200;
c0.message();
}
}
对象放在堆内存中
c变量名中存储的是对象再堆内存中的地址
成员变量的数据存放在堆内存中
3.垃圾回收
- 当堆内存中的类对象或者数组对象，没有被任何变量引用(指向)时，就会被判定为内存中的垃圾。
- Java存在自动垃圾回收器，会定期进行清理。
4.构造器
构造器的作用
- 用于初始化一个类的对象，返回对象的地址。
分类
- 无参构造器(默认存在的):初始化对象时，成员变量的数据均采用默认值
- 有参构造器:在初始化对象的时候，同时可以为对象进行赋值
定义格式
修饰符 类名(形参列表){
...
}
注意事项
- 任何类定义出来，默认就带了无参构造器
- 一旦定义了有参构造器，无参构造器就没有了，此时需要自己写一个无参构造器
5.this关键字
出现在成员方法、构造器中代表当前对象的地址，用于访问当前对象的成员变量、成员方法
public class Student {
String name;
int age;
//构造器中使用this关键字
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//成员方法中使用this关键字
public void study(String name) {
System.out.println(this.name + "和" + name + "在学习");
}
}
6.封装
隐藏实现细节，暴露出合适的访问方式（合理隐藏，合理暴露）
封装的实现步骤
- 一般对成员变量使用private(私有)关键字修饰进行隐藏，private修饰后该成员变量就只能在当前类中访问。
- 通过getter和setter方法暴露访问
好处： - 加强了程序代码的安全性
- 适当的封装可以提升开发效率，同时让程序更容易理解与维护
7.static关键字
static是静态的意思，可以修饰成员变量，表示该成员变量只在内存中存储一份，可以被共享访问、修改
static修饰成员变量，成员变量可以分为两类
- 静态成员变量（有static修饰，属于类，内存中加载一次）
- 访问方式：类名.静态成员变量、对象名.静态成员变量(不推荐使用)
- 实例成员变量（无static修饰，存在于每个对象中）
- 访问方式：对象名.变量名
![]()
static修饰成员方法，成员方法分为两类
- 静态成员方法（有static修饰，属于类，修饰通用功能）
- 访问方式：类名.静态成员方法、对象名.静态成员方法(不推荐使用)
- 实例成员方法（无static修饰，属于对象，表示对象自己的行为）
- 访问方式：对象名.方法名
![]()
注意事项：
- 静态方法只能访问静态成员，不可以直接访问实例成员。
- 实例方法可以访问静态成员，也可以访问实例成员。
- 静态方法中不能出现this关键字
7.1工具类
对于一些应用程序中多次需要用到的功能，可以将这些功能封装成静态方法，放在一个类中，这就是工具类。
工具类的作用：
- 方便调用
- 提高了代码复用
工具类原理和延申
- 一次编写，处处可用
- 建议将工具类的构造器私有，不让工具类在外构造对象
//验证码工具类
public class VerifyCode {
public static String createCode(int n){
String code = "0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
String codeResult = "";
Random r = new Random();
for (int i = 0; i < n; i++) {
int index = r.nextInt(code.length());
codeResult += code.charAt(index);
}
return codeResult;
}
}
8.代码块
代码块是类的5大成分之一，定义在类中方法外
在Java类下，使用{}括起来的代码被称为代码块
静态代码块
- 格式：static{}
- 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
- 使用场景：在类加载的时候做一些静态数据初始化操作，以便后续使用
构造代码块
- 格式：{}
- 特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。
- 使用场景：初始化实例资源。
//静态代码块实例
public class Demo {
public static String name;
//与类一起加载，自动触发一次，优先执行
static{
System.out.println("==静态代码块触发执行==");
name = "张三";
}
public static void main(String[] args) {
//可以在程序加载时进行静态数据的初始化操作
System.out.println("===main方法执行输出===");
System.out.println(name);
}
}
输出结果
public class Demo {
/*
构造代码块，属于对象，与对象一起加载，自动触发执行
*/
{
System.out.println("==构造代码块触发执行一次==");
}
public Demo(){
System.out.println("==构造器被触发执行==");
}
public static void main(String[] args) {
new Demo();
}
}
输出结果
9.单例设计模式
设计模式是一套被前人反复使用，多数人知晓、经过分类编目的代码设计经验的总结，后者可以直接拿来解决问题
单例模式
- 可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
单例的场景和作用
- 例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。
饿汉单例设计模式
- 在用类获取对象的时候，对象已经提前为你创建好了。
设计步骤：
- 定义一个类，把构造器私有。
- 定义一个静态变量存储一个对象。
//饿汉单例模式实例
public class SingleInstance {
/*
定义静态变量存储一个对象
*/
public static SingleInstance si = new SingleInstance();
/*
将构造器私有化
*/
private SingleInstance(){}
}
懒汉单例设计模式
- 在真正需要该对象的时候，才去创建一个对象（延迟加载对象）
设计步骤
- 定义一个类，把构造器私有。
- 定义一个静态变量存储一个对象。
- 提供一个返回单例对象的方法。
//懒汉单例实例
public class SingleInstance {
/*
定义静态变量存储一个对象
*/
private static SingleInstance si;
/*
将构造器私有化
*/
private SingleInstance(){}
/*
提供一个方法返回一个单例对象
*/
public static SingleInstance getInstance(){
if (si == null){
si = new SingleInstance();
}
return si;
}
}
10.继承
- 继承是子类与父类之间的一种关系
- 多个类继承单独的某个类，多个类就使用单独的这个类的属性和行为了
- 多个类称为子类（派生类），单独的这个类称为父类（基类或超类）
- 使用继承的好处：提高代码的复用，减少代码冗余，增强类的功能扩展性
继承的格式
- 继承的关键字extends
- public class 子类名称 extends 父类名称 {}
继承设计规范
- 子类们相同的特征(共性属性，共性方法)放在父类中定义，子类独有的属性和行为应定义在子类里面
- 如果子类的独有属性，行为定义在父类中，会导致其它子类也会得到这些属性和行为，这不符合面向对象的逻辑
继承的特点
- 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
- java是单继承模式：一个类只能继承一个直接父类
- java不支持多继承，但是支持多层继承
- java中所有的类都是Object的子类
在子类方法中访问成员（成员变量、成员方法）满足：就近原则
- 先子类局部范围找
- 然后子类成员范围找
- 然后父类成员范围找，如果父类范围还没找到就报错
方法重写
- 在继承体系中，子类出现了和父类一摸一样的方法声明，我们就称子类这个方法是重写的方法。
方法重写的应用场景
- 当子类需要父类的功能，但父类的该功能不完全满足自己的需求时
@Override重写注释
- @Override放在重写后的方法上，作为重写是否正确的校验注解
- 加上该注解后如果重写错误，编译阶段会出现错误提示
- 建议重写方法都加@Override注解，代码安全，优雅
方法重写注意事项和要求
- 重写方法名称，形参列表必须与被重写方法的名称和参数列表一致
- 私有方法不能被重写
- 子类重写父类方法时，访问权限必须大于或者等于父类
- 子类不能重写父类的静态方法(因为子类不能继承父类的静态方法)
- 子类构造器的第一行语句默认都是super()，不写也存在
继承后子类构造器的特点
- 子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己
- 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据
- 子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化
子类构造器访问父类有参构造器
- super调用父类有参构造器能初始化继承自父类的数据
- 父类中如果只有有参构造器，子类中会报错，因为子类默认是调用父类无参构造器，可以通过在子类构造器中书写super(...)手动调用父类的有参构造器
this和super关键字
- this代表本类对象的引用;super代表父类存储空间的标识。
- this/super.成员变量(访问本类/父类成员变量)
- this/super.成员方法(...)(访问本类/父类成员方法)
- this/super(...)(访问本类/父类构造器)
- 子类通过this(...)去调用本类的其他构造器，本类其他构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器的
- this(...)和super(...)都只能放在构造器的第一行，所以二者不能存在一个构造器中
浙公网安备 33010602011771号