Java面向对象编程

面向过程思想与面向对象思想

面向过程思想：

• 步骤清晰简单，第一步做什么，第二部做什么
• 适合处理一些较为简单的问题

面向对象思想：

• 物理类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行独立思考，最后才对某个分类下的细节进行面向过程的思考
• 适合处理复杂的问题以及多人协作的问题

总之，对于描述复杂的事物，运用面向对象思路分析整个系统，运用面向过程思路处理微观操作

什么是面向对象

面向对象本质：以类的方式组织代码，以对象的形式组织（封装）数据
三大特性：

• 封装
• 继承
• 多态

类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是不能带便某一个具体的事物
• 对象是抽象概念的具体实例
• 类就像是创建对象的模板
• 属性：字段field，成员变量，会默认初始化（数字：0 0.0、char：u0000、boolean：false、引用：NULL）
• 类中：静态的属性（属性），动态的行为（方法）

创建与初始化对象

使用new关键字创建对象

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

类		对象
Student xiaoMing = new Student();

构造器（也称构造方法）

1.构造器是在进行创建对象必须调用的

2.构造器特点

• 必须和类的名字相同
• 必须没有返回类型，不能写void

3.构造器作用：用来初始化对象的值
3.构造器常常与重载一起用，应付创建对象传递参数的情况
4.有参构造：一旦定义了有参构造，无参构造就必须显式定义，不然new一个无参的对象会报错

public class Student {
    String name;
    int age;
    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

创建对象内存分析

• 引用变量名会存在栈中，真正指向的对象存在于堆中
• 而方法会存在堆中一个特殊的方法区，静态方法（static关键字修饰的方法）会存在静态方法区
• 引用类型：对象是通过引用来操作的

修饰符

范围：public>protected>default>private
final 常量

面向对象三大特性

封装(private 属性)

• 封装（数据的隐藏）：通常，应禁止直接访问一个对象中的实际表示，而应通过操作接口来访问（信息隐藏）
• 属性私有：get/set
• 给属性加上private修饰符，用get/set方法操作属性
• 程序设计要追求“高内聚低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用
• 封装的作用：提高程序的安全性保护数据、隐藏代码的实现细节、统一接口、系统可维护增加了

public class Student {
    private String name;
    private int age;
    private String sex;

    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>0 && age<100) {
            this.age = age;
        }else{
            this.age = 3;
            System.out.println(this.age+" years od puppy");
        }
    }

继承(extends)(单继承）

• 继承的本质是对某一批类的抽象，从而对现实世界更好的建模
• Java中类只有单继承没有多继承
• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等
• 子类继承父类，就会有父类的全部方法
• new子类对象时，会默认先调用父类无参构造器

object类

在Java中，所有的类都默认直接或间接继承object

super与this

1.super的注意点

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或构造方法中
• super和this不能同时调用构造方法
  2.super与this的不同
  代表的对象不同
• this：本身调用者这个对象
• super：代表父类对象的应用
  前提
• this：没有继承也能使用
• super：只有在继承条件下才可以使用
  构造方法
• this() ：本类的构造
• super() ：父类的构造

方法的重写(@Override)

1.重写是方法的重写与属性无关
2.@Override ：注解，有功能的注释
3.重写：需要有继承关系，子类重写父类的方法
4.要求：

• 方法名必须相同
• 参数列表必须相同
• 修饰符范围可以扩大但不能缩小
• 抛出的异常的范围可以被缩小但不能扩大
  为什么需要重写？
• 父类的功能，子类不一定需要，或者不一定满足

总之，重写就是子类的方法名和父类必要一致，方法体不同

多态（父类的引用指向子类）

多态：即同一种方法可以根据发送对象的不同而采用多种不同的行为方式

多态存在的条件

• 有继承关系
• 子类重写父类的方法
• 父类引用子类的对象

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

多态注意事项

• 多态是方法的多态，和属性无关
• 父类和子类有联系

instanceof以及类型转换

System.out.println(x instance of y);

• x和y无父子关系，编译报错
• x为y子类型，返回true

抽象类(单继承）

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

public abstract class Action {
    public void hello(){
        System.out.println("Hello");
    }
    //Abstract method
    public abstract void doSomething();
}

实现抽象类的子类

public class A extends Action{
    @Override
    public void doSomething(){
        System.out.println("I achieved the abstract doSomething method");
    }
}

接口（多继承）

普通类：只有具体的实现
抽象类：具体的实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，专业的约束，约束和实现分离

• 接口就是规范，其本质是契约，制定后人人遵守
• oo的精髓是对对象的抽象，最能体现这一点的就是接口
• 声明接口的关键字是interface
• 实现了接口的类就需要重写接中口的犯法
• 接口不能被实例化，接口中没有构造方法
• implements可以实现多个接口

接口

public interface UserService {
    void run();
    void add();
    void sub();
    void mul();
    void div();
}

接口

public interface TimeService {
    void time();
}

实现

public class UserServiceImpl implements UserService, TimeService{
    @Override
    public void time() {

    }

    @Override
    public void run() {

    }

    @Override
    public void add() {

    }

    @Override
    public void sub() {

    }

    @Override
    public void mul() {

    }

    @Override
    public void div() {

    }
}

内部类

1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类