面向对象编程（OOP）
初识面向对象
- 面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么…
- 面向过程适合处理一些较为简单的问题
- 面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
- 面向对象适合处理复杂问题，适合处理需要多人协作的问题
- 本质：以类的方式组织代码，以对象的组织（封装）数据
类与对象的关系
- 类是一种抽象的数据类型，它对某一类事物描述/定义，但是并不能代表某个具体的事物
- 对象是抽象概念的具体实例
对象的创建分析
- 使用new关键字创建对象
- 使用new关键字的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
- 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
- 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点
- 栈中放变量，堆中放对象
面向对象三大特性
-
封装
高类聚，低耦合
- 高类聚就是类的内部数据操作细节自己完成，不允许外部干涉
- 低耦合：仅暴露少量方法给外部使用
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问
属性私有，通过get/set方法使用
-
继承（extands）
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
-
java类中只有单继承，没有多继承
-
私有的无法继承
-
Object类是所有类的父类
-
super
调用父类的属性或者方法
super.fathermethod(); super.fatherattribute;注意：
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中
-
super和this不能同时调用构造方法
this：本身调用这个对象
super：代表父类的应用
前提
this：没有继承也可以使用
super：只能在继承条件下使用
构造方法
this（）：本类的构造器
super（）：父类的构造器
-
-
重写：需要有继承关系，子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小：private->protected->default(不写的情况下自动生成)->public
- 抛出异常：可以被缩小，但不能扩大
-
-
多态
同一个方法可以根据发送对象的不同采用多种不同的行为方式
-
存在的条件：
-
有继承关系 类型转换异常：ClassCastException
-
子类重写父类方法
无法重写的方法：
- static方法：属于类，不属于实例
- final 常量池
- private 方法
-
父类引用指向子类对象
Father son1=new Son();
-
-
多态是方法的多态，不是属性的多态
-
关键字 instanceof （类型转换）引用类型，判断一个对象是什么类型
Father instanceof Son;如果存在父子关系就返回true
反之则返回false
-
Static 关键字详解
package Static;
public class StaticTest {
public static void main(String[] args) {
left();
new StaticTest().go();
person person1 = new person();
System.out.println("============");
person person2 = new person();
}
public static void left(){
System.out.println("left");
}
public void go(){
System.out.println("go");
}
}
class person{
//2
{
System.out.println("匿名代码块");
}
//1 只执行一次 在类加载的时候执行
static {
System.out.println("静态代码块");
}
//3
public person() {
System.out.println("构造器");
}
}
抽象类和接口
抽象类
- abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类
- 抽象类可以没有抽象方法，但有抽象方法的类一定要声明为抽象类
- 抽象类不能使用new关键字来创建对象，它是用来让子类继承的
- 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
- 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也哟啊声明为抽象类
package Abstract;
public class AbstractTest {
public static void main(String[] args) {
Father a=new Son();
a.doSomething();
}
}
//abstract 抽象类 单继承 （接口可实现多继承）
abstract class Father{
public abstract void doSomething();
}
class Son extends Father{
@Override
public void doSomething() {
System.out.println("doSomething");
}
}
接口
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有
- 接口：只有规范
package 接口;
public class InterfaceTest {
public static void main(String[] args) {
UserService userService=new UserServiceImpl();
int id=1;
userService.del(id);
userService.select(id);
userService.update(id);
}
}
interface UserService{
//常量 public static final
int id=0;
void select(int id);
void del(int id);
void update(int id);
}
class UserServiceImpl implements UserService{
@Override
public void select(int id) {
System.out.println("select操作");
}
@Override
public void del(int id) {
System.out.println("delect操作");
}
@Override
public void update(int id) {
System.out.println("update操作");
}
}
内部类及oop实战
内部类
- 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了
分为：
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
package 内部类;
public class outerTest{
public static void main(String[] args) {
//实例化外部类
outer outer = new outer();
outer.out();
//实例化外部类
outer.in in = outer.new in();
in.in();
in.getId();
}
}
class outer {
private int id=1;
public void out(){
System.out.println("这是外部类的方法");
}
public class in{
public void in(){
System.out.println("这是内部类的方法"
);
}
//获得外部类的私有属性
public void getId(){
System.out.println("外部的私有属性："+id);
}
}
}