面向对象编程

xmingggg

已于 2022-04-01 16:54:53 修改

阅读量255

点赞数

文章标签： java

于 2022-03-31 22:32:00 首次发布

本文链接：https://blog.csdn.net/qq_45689101/article/details/123831715

版权

面向过程

步骤清晰简单，第一步做什么，第二步做什么（类似线性思维）
适用于简单问题

面向对象

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
适用于复杂问题

面向对象编程OOP

本质：以类的方式组织代码，以对象的方式组织（封装）数据
三大特征：封装、继承、多态

从知识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

OOP的方法

修饰符 返回值类型 方法名(){
	//方法体
	return 返回值;
}
//return 结束方法
//break 跳出循环，跳出swith

static

静态方法：有static，可以由类名.方法名直接调用，和类一起加载，类加载时就被加载到了内存中，整个运行过程保持不变，可以被重载，但不能被重写
非静态方法：无static，需要把类实例化（new 一下），再进行方法调用，是类实例化之后才被加载到内存中的，可以被重载和重写

public void a(){
	b();//可以直接调用
}
public static void b(){
	a();//报错
}
//当两种方法类型一样时，可相互调用

类和对象

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例

创建对象&&构造器

使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也称为构造方法，实在进行创建对象的时候必须要调用的，并且构造器有以下两个特点
必须和类的名字相同
必须没有返回类型，也不能写void

public class stu{
	public stu(){}//构造方法（alt+insert）
}
//每个类包括抽象类都至少有一个构造方法，可以有多个，但参数不同，构造方法可以初始化对象的值
//一旦定义了有参构造，还想用无参构造new对象，则无参构造必须显示定义
//一个java文件中只能由一个public class，可以有多个class

总结

类和对象
类是一个模板，对象是一个具体的类
方法
定义，调用
对象的引用
引用类型：基本类型（8种）
对象是通过引用来操作的：栈–>堆
属性：字段Field 成员变量
默认初始化：
数字：0，0.0
char：u0000
boolean：false
引用：null
对象的创建和使用
- 必须使用new关键字创建对象，构造器 Person xmingggg = new Person（）
- 对象的属性 xmingggg.name
- 对象的方法 xmingggg.sleep（）
类：
静态的属性属性
动态的行为方法

封装（数据的隐藏）

程序设计追求：高内聚，低耦合
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅保护少量的方法给外部使用。

封装核心：禁止直接访问数据的实际表示，应通过操作接口来访问，属性私有 private，get/set (public)

继承

继承的本质是对一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”，子类是父类的扩展
Java中类只有单继承，没有多继承
在java中所有的类，都直接或间接继承Object
私有的东西无法被继承private
子类的构造函数默认调用父类的构造函数，super()在第一行隐藏了

super

super 调用父类的构造方法，必须在构造方法的第一个
super 必须只能出现在子类的方法或者构造方法中
super 和 this 不能同时调用构造方法，因为都要在第一行

super vs this

代表的对象不同
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法
this()：本类的构造
super()：父类的构造

方法重写

需要有继承关系，子类重写父类方法
方法名必须相同
参数列表必须相同
修饰符，范围可以扩大 public>protescted>default>private
抛出的异常可以被缩小，但不能扩大

//重写都是方法的重写，与属性无关

class B
public void test(){
	System.out.println("B");
}

class A extends B
@Override //重写，注解：有功能的注释
public void test(){
	System.out.println("A");
}

main
A a = new A();
a.test();//输出A
//父类的引用指向子类
B b = new A();
b.test();//输出A，子类重写了父类执行子类
//如果是静态方法，因为不能重写，则输出A B

多态：弥补单继承缺陷

多态是方法的多态，属性没有多态
父类和子类，有联系，类型转换异常ClassCastException
存在条件：继承关系，方法需要重写，父类的引用指向子类对象

Son s = new son();
Father f = new son();
//子类可以调用自己的和从父类继承的所有方法
//父类可以指向子类，但不能调用子类独有的方法

instanceof

在运行时判断对象是否是指定类或其父类的一个实例，比较的是对象，不能比较基本类型。

Son s = new Son();
System.out.println(s instanceof Father);//返回boolean类型

Object > Person >Student
Object > Person >Teacher
Object > String

Object object = new Student();
Student student = new Student();
Person person = new Student();

object instanceof Object
object instanceof Person
object instanceof Student //true
object instanceof Teacher
object instanceof String //false

student instanceof Object
student instanceof Person
student instanceof Student //true
student instanceof Teacher //编译错误
student instanceof String //编译错误

person instanceof Object
person instanceof Person 
person instanceof Student //true
person instanceof Teacher //false
person instanceof String //编译错误

//只有是父子关系时才能输出，否则编译报错

抽象类

/*
抽象类：不能new，只能靠子类去是实现，规范！
		抽象类中可以写普通方法
		抽象方法必须在抽象类中 
*/
public abstract class Action{
	//抽象方法，只有方法名字，没有方法实现
	public abstract void do();
}

接口：OOP的精髓

/*
接口：只有规范，本质是契约	 
	  约束和实现的分离：面向接口编程
	  接口都需要有实现类，多继承
	  无构造函数，不能被实例化
*/
public interface UserService{
	//接口中属性默认常量 public static final
	//方法默认public abstract
	public abstract void run();
}

//实现了接口的类，就必须实现接口的所有方法
public class UserServiceImple implements UserService{
	public abstract void run(){
		//方法体
	}
}

可以new 接口名称{实现接口的方法}，本质是匿名类

内部类

public class Outer{
	private int id = 10;
	public void out(){
		System.out.println("外部类的方法");
	}
	public class Inner{
		public void in(){
		System.out.println("内部类的方法");
		}
		//可以获得外部类的私有属性
		public void getID(){
		System.out.println(id);
		}
	}
}

//main
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner
inner.in();//内部类
inner.getID();//10