java面向对象

面向对象编程

本质：以类的方式组织代码，以对象的组织封装数据。

三大特性

• 封装
• 继承
• 多态
  从认识论角度看， 先有对象后有类。对象是具体的事物。类是抽象的。
  从代码运行角度看，先有类后有对象。类是对象的模板。

类与对象的关系

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

创建与初始化对象

• 使用new关键字创建对象。使用new创建对象时，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的调用。
• 类中构造器也称为构造方法，是在进行创建对象时必须调用的方法。并且构造器有两个特点：1.必须和类的名字相同。2.必须没有返回类型，也不写void.
  

封装

• 高内聚，低耦合。高内聚是指类的内部数据操作细节自己完成，不允许外部干涉；低耦合指仅暴露少量的方法给外部使用。
• 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，即信息隐藏。
• 属性私有，get/set。

public class Student {
    /*
    提供一些可以操作这个属性的方法。
    提供一些pubic的get，set方法
    封装的好处：1.提高程序的安全性，保护数据。
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护增加
     */
    private String name;
    private  int id;
    
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

继承

• extands扩展。子类是父类的扩展。
• 继承是类与类之间的关系。其中还有依赖，组合，聚合。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extands表示。
• java类中只有单继承，没有多继承。

// An highlighted block
//父类
public class Teacher {
    public void say(){
        System.out.println("hello world");
    }
}

//学生 子类
public class Student extends Teacher{
}
//测试类
public class Appplication {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
    }
}

 输出hello world
 

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个。
2.super必须只能出现在子类的方法或者构造方法中。
3.super和this不能同时调用方法
this：
代表的对象不同：
this：本身调用者这个对象。
super：代表父类对象的应用。
前提
this：没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this（）;本类构造
super（）;父类构造

重写

重写：需要有继承关系，子类重写父类方法。
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小。
public>protected>default>private
4.抛出异常：范围可以被缩小，但不能扩大
重写：子类的方法和父类必要一 致；方法体不同Excption!
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足。

多态

• 即同一种方法可以根据发送对象的不同而采取多种不同的行为方式。
• 一个对象的实际的实际类型是确实的，但可以指向对象的引用的类型有很多。
• 多态存在的条件：1.有继承关系2.子类重写父类方法3.父类引用指向子类对象。
• 注意：多态是方法的多态，属性没有多态性。

instanceof

// 引用类型对比
System.out.println(X instanceof Y);

static静态扩展

静态代码块只执行一次

//静态导入包
import static java.lang.Math.random;
//静态可以直接调用Math类调用里面的方法

抽象类

• abstract修饰符可以用来修饰方法和类，如果修饰方法该方法为抽象方法，如果修饰类该类为抽象类。
• 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。
• 抽象类不能使用new关键字来创建对象，能让子类继承。
• 抽象方法，只有方法的声明，没有方法的实现，是用来子类实现的。
• 子类继承抽象类，必须实现抽象类没有实现的抽象方法，否则改子类也要申明为抽象类。

public abstract class Action {
    //abstract,抽象方法，只有方法名字，没有方法实现。
    public abstract void doSomething();
}
//抽象类的所有方法，继承子类，必须实现它的方法。
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

• 接口不能被实例化，接口中没有构造方法。
• 接口中所有定义其实都是抽象的。
• 实现接口的类必须重写接口的方法。

//interface接口定义关键字，接口都需要实现类
//接口中所有定义其实都是抽象的
public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

//抽象类：extends
//类 可以实现接口 implements 接口
//实现接口的类必须重写接口的方法
//多继承，利用接口实现
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类。

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类
• lambada