Java面向对象
面向对象编程：OOP
初始面向对象
属性+方法=类
面向对象&面向过程
面向过程思想：步骤简单清晰，适合处理一些较为简单的问题
面向对象思想：分类的思维模式，首先解决问题需要哪些分类，对分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。适合处理复杂，需要多人协作的问题。
本质：以类的方式组织代码，以对象的形式组织（封装）数据。
抽象
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。（因为先想到要做什么（对象），再去找办法（类））。先有具体的对象，再去抽象出类（抽象出这些人的共同点）.就是在一堆人里，有一半是老师就抽象出一个类：老师。
从代码运行角度考虑是先有类。类是对象的模板（先找到共同点，确定一个类）先抽象出一个类：老师，再把那一堆人里是老师的封装出来。
三大特性：
- 封装
- 继承
- 多态：同一种事物有多种形态（一个人生很多孩子，虽然每个孩子都长的不一样，但是都是你的孩子）
方法回顾和加深
方法的定义：
- 修饰符
- 返回类型
- break：跳出switch，结束整体循环和return：结束方法，返回一个结果
- 方法名：注意规范，见名知意
- 参数列表：（参数类型，参数名），（int...b）可变参数
- 异常抛出
方法的调用：
-
静态方法：和类一起加载
-
非静态方法：
- 不用类的非静态方法，只能实例化（new Student().say()）,new+类名+方法名 。Student student=new Student（），再调用 student。say（）
- 一个类的两个方法，两个都是静态或者非静态，则上面的可以直接调用，如果上面的是静态，下面是非静态，上面就不可以直接调用下面的方法。
没看懂
![屏幕截图 2025-08-04 144611]()
-
形参和实参
-
值传递和引用传递
-
this关键字
对象的创建分析
类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例
练习：先写一个方法，再在main方法里调用，赋值，输出
点击查看代码
package com.xin.oop;
import com.xin.oop.Demo3.Pet;
//一个项目应该只存一个main方法
public class Applicaton {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "小白";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
/**
* package com.xin.oop.Demo3;
public class Pet {
public String name;
public int age;
public void shout() {
System.out.println("叫了一声");
}
}
*/
/**
* public static void main(String[] args) {
* Student student = new Student();
* //类实例化后会返回一个自己的对象
* //对象就是类的一个具体实例
* Student xiaoming = new Student();
* xiaoming.name = "小明";
* xiaoming.age = 3;
* System.out.println(student.name);
* System.out.println(xiaoming.name);
* System.out.println(xiaoming.age);
* }
* package com.xin.oop.Demo2;
*
* //学生类
* public class Student {
* // 属性：字段
* String name;
* int age;
*
* // 方法
* public void study() {
* System.out.println(this.name + "在学习");
* }
* }
*
*/
/**
* package com.xin.oop.Demo2;
*
* //一个项目应该只存一个main方法
* public class Applicaton {
* public static void main(String[] args) {
* // 实例化一个对象
* Person person = new Person();
* //调用第一个无参
* System.out.println(person.name);
* Person person1 = new Person("xixi");
* //有了参数就调用第二个有参构造器
* System.out.println(person1.name);
* }
*
* }
*
* package com.xin.oop.Demo2;
*
* public class Person {
* String name;
*
* // 即使什么都不写也默认有一个方法
* // public Person(){}
* // 这个方法没有返回值,和类的名字相同
* public Person() {
*
* }
*
* public Person(String name) {
* // 前一个name是属性，后一个是局部变量
* this.name = name;
* }
* }
*
*/
使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始值以及对类中构造器的调用。
- 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
- 构造器：必须要在同一层包下
- 实例初始值
- 使用new关键字，本质是在调用构造器
- 一旦定义有参构造，想调用无参构造必须显示定义，也就是必须手写无参构造器。
- 有参和无参同时出现相当方法的重载
创建对象内存分析
小结：
- 类与对象：类是一个模板，对象是一个具体的实例
- 方法：定义，调用
- 对应的引用：引用类型：对象是通过引用来实现的。基本类型（8）
- 属性：字段Field 成员变量。
修饰符 属性类型 属性名=属性值 。修饰符（public之类的）
默认初始化：- 数字：0 /0.0
- char:u0000
- boolean:false
- 引用：null
- 对象的创建和使用：
- 必须使用new关键字创造对象，还要有构造器
- 对象的属性 Person xixi = new Person（）；
属性是：xixi。name - 对象的方法：xixi.sleep()
- 类：由属性和方法组成
- 静态的属性： 属性
- 动态的行为： 方法
面向对象的三大特性
封装：属性私有 private set/get
private String name;
private char sex;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public void setSex(char sex) {
this.sex = sex;
}
public char getSex() {
return sex;
}
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("xin");
System.out.println(s1.getName());
}
继承：的本质是对某一些类的抽象
- extends的意思是扩展，子类是父类的扩展
- java类中只有单继承，没有多继承！：一个儿子只有一个爸爸，一个爸爸可以有多个儿子。
- 继承是类和类之间的一种关系。
- 继承关系的两个类，一个为字类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
- 子类和父类之间，从意义上来讲应该具有”is a“的关系。
- 子类会继承父类所有的方法。（修饰符pubilc）
- object类：在java中所有的类，都直接或间接继承object类
- super
注意：
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
vs this
- 代表对象不同：
- this：本身调用者这个对象
- super：代表父类对象的应用
- 前提：
- this：没有继承也可以使用
- super：只能在继承条件才可以i使用
- 构造方法：
- this（）：本类的构造
- super（）:父类的构造
点击查看代码
package com.xin.oop.Demo2;
//学生类
public class Student extends Person {
private String name = "xi";
public Student() {
// 隐藏代码super（）;继承了父类的构造器，必须放在子类构造器的第一行
System.out.println("student无参执行");
}
public void test(String name) {
System.out.println(name);
// 这个是传的参数
System.out.println(this.name);
// 这个是private定义了的属性
System.out.println(super.name);
// 用super调用父类属性
}
public void print() {
System.out.println("student");
}
public void test1(String name) {
print();
this.print();
super.print();
}
}
package com.xin.oop.Demo2;
public class Person {
public Person() {
System.out.println("person无参执行");
}
protected String name = "xin";
public void print() {
System.out.println("person");
}
}
* public static void main(String[] args) {
* // 实例化对象可以调用
* Student student = new Student();
* // student.test("xixi");
* // 这个就是传的参数
* student.test1(null);
* }
私有的东西无法被继承，一般可以写protected
隐藏代码super（）;继承了父类的构造器，必须放在子类构造器的第一行
当父类的写了有参构造，就不能再写无参构造了，父类不能写无参，子类也就不能调用父类无参，只能调用有参，
5. 方法重写
重写是方法的，和属性无关
静态方法属于类本身，正确的调用方式是通过类名直接调用而不是实例化
点击查看代码
package com.xin.oop;
import com.xin.oop.Demo4.A;
import com.xin.oop.Demo4.B;
//import com.xin.oop.Demo2.Student;
public class App {
public static void main(String[] args) {
A a = new A();
a.test();
// 父类的引用指向子类
B b = new A();
b.test();
}
}
package com.xin.oop.Demo4;
public class A extends B {
public void test() {
// super.test();
System.out.println("A>=test()");
}
}
package com.xin.oop.Demo4;
public class B {
public void test() {
System.out.println("B>=test()");
}
}
重写：子类的方法必须和父类一致，方法体不同。
- 非静态才可以重写，属性只有是public才可以，static类不可以进行方法重写。用static直接调用A.test(),B.test()，会分辨输出各自类的方法里的输出，因为A是继承B的
- 重写是子类的访问权限不能比父类严格，所有不可以是private，修饰范围可以扩大。public>protected>default>private
- 需要有继承关系，子类重写父类的方法
- 参数列表必须相同
- 抛出的异常：范围可以被缩小，但不能扩大。
多态：同一个方法可以根据发生对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向的对象的引用的类型有很多。
多态存在的条件：
- 有继承关系
- 子类重写父类方法，不可重写的：
- static方法属于类，不属于实例
- final常量
- private私有属性
- 父类引用指向子类对象 father f1= new son();
注意事项：
- 注意：多态是方法的多态，属性没有多态性
- 父类和子类，有联系，类型转换异常！ClassCastException
instanceof 类型转换
父子关系之间联系才有true
点击查看代码
ackage com.xin.oop;
import com.xin.oop.Demo2.Person;
import com.xin.oop.Demo2.Student;
public class App1 {
public static void main(String[] args) {
// 父类的引用指向子类
Person student = new Student();
//student能调用的方法都是自己的或者继承父类的。
//person 不能调用子类独有的方法
Student s1 = new Student();
s1.run();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
student.run();//子类重写了父类的方法就执行子类的方法
Object object = new Object();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);
System.out.println(object instanceof Object);
System.out.println(object instanceof String);//false
}
}
Person obj = =new Student（）；
高转低:会丢失一些方法
Student student= （Student) obj;
((Student)obj).go();
static关键字
点击查看代码
package com.xin.oop.Demo5;
//静态导入包
import static java.lang.Math.random;
public class Person {
{
//可以赋初始值
System.out.println("匿名代码块");
}
// static只执行一次并且在第一次的时候先执行，其他的都每次都可以执行
static {
System.out.println("静态代码块");
}
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
Person person2 = new Person();
System.out.println(random());
}
}
抽象类和接口
抽象类
- abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。
- 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
- 抽象类，不能使用neew关键字来创建对象，它是用来让子类继承的。
- 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
- 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
接口
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有
- 接口：只有规范
- 接口就是规范，定义的是一组规则，体现了显示世界中“如果你是。。。，则必须能。。。”的思想
- 接口本质是契约，就像我们人间的法律一样，制定好后大家都遵守
- oo的精髓，事对对象的抽象，最能体现这一点的就是接口。
- 声明类的关键字是class，声明接口的关键字是interface。
- 接口里的东西都是抽象的 publicabstract
可以直接void run（）； - 接口都需要实现类 用:implements 接口
- 实现接口中的类就必须重写接口里的方法
- 利用接口实现多继承,接口不能被实例化，接口中没有构造方法
- 常量:public static final
点击查看代码
package com.xin.Abstract.Demo1;
public abstract class Action {
public abstract void test();
public static void main(String[] args) {
Act act = new Act();
act.test();
}
}
package com.xin.Abstract.Demo1;
public class Act extends Action {
public void test() {
System.out.println("子类实现了抽象类");
}
}
内部类及OOP实战
内部类就是在一个类中再定义一个类
通过外部类来实例化内部类
outer.inner inner = outer.new inner();
inner.in//调用内部类方法
可以获得外部类的私有属性
浙公网安备 33010602011771号