Java面向对象编程

初识面向对象

面向过程&面向对象

• 面向过程思想
  • 步骤清晰简单,第一步做什么，第二步做什么…
  • 面对过程适合处理一些较为简单的问题
• 面向对象思想
  • 物以类聚,分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
• 对于描述复杂的事物，为了从宏观.上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象编程(Object-Oriented Programming, 00P)
• 面向对象编程的本质是:以类的方式组织代码,以对象的组织(封装)数据
• 抽象
• 三大特性
  • 封装
  • 继承
  • 多态
• 从认识论角度考虑是先有对象后有类,对象是具体的事物,类是抽象的,是对对象的抽象
• 从代码运行角度考虑是先有类后有对象,类是对象的模板

方法回顾和加深

• 静态方法:和类一起加载

public static void add(int a,int b){
        System.out.println(a+b);
    }

• 非静态方法:类实例化的时候被加载,就是new出一个对象的时候加载

public void add(int a,int b){
        System.out.println(a+b);
    }

• 两个方法都为静态或非静态的时候才能相互调用

对象的创建分析

类与对象的关系

• 类是一种抽象的数据类型,它是对某- 类事物整体描述/定义,但是并不能代表某一 个具体的事物.
  • 动物、植物、手机、电脑… .
  • Person类、Pet类、 Car类等, 这些类都是用来描述/定义某-类具体的事物应该具备的特点和行为
• 对象是抽象概念的具体实例
  • 张三就是人的一个具体实例,张三E家里的旺财就是狗的-个具体实例。
  • 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.

创建于初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化一级对类中构造器的调用
• 类的构造器也称为构造方法,实在进行创建对象的时候必须调用的,并且构造器有以下两个特点:
  1. 必须和类的名字相同
  2. 必须没有返回类型,也不能写void
• 构造器的使用
  • 使用new关键字本质是在调用构造器
  • 有参构造:一旦定义了有参构造,无参构造必须显示定义
  • 初始化参数的值
  • Alt+Insert组合键选择Constructor可以自动生成构造函数

public class Person {
    public Person(){//无参构造
        
    }
    //定义了有参构造,必须再定义一个无参构造,两个一起存在
    public Person(String name){//有参构造
        
    }
}

面向对象三大特性

封装

• 该露的露,该藏的藏
  • 我们程序设计要最求**“高内聚,低耦合”**,高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用
• 封装(数据的隐藏)
  • 通常,应禁止访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏
• 记住这句话就够了:属性私有,get/set
• 下面关键字的详解

//class类声明变量和方法的关键字,赋予变量和方法不同的访问权限
public		//公共的,只要new了这个类就可以使用
protected	//受保护的,成员不能直接被类的实体访问，但是可以被子类访问，也可以被类的成员函数访问；
private 	//私有的,只有当前类里面的方法可以使用

• 封装的意义
  • 提高程序的安全性,保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 增加系统的可维护性

继承

• 继承的本质是对某一批类的抽象,从而实现对现实世界更好地建模

• extands的意思是"扩展",子类是父类的扩展

• JAVA只有单继承,没有多继承

• 继承是类和类之间的关系,除此之外,类和类之间的关系还有依赖、组合、聚合等

• 继承关系的俩类,一个为子类(派生类),一个为父类(基类),子类继承父类,使用关键字extands来标志

• 子类和父类之间,从意义上将应该具有"is a"的关系

• object类

• super

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

• 方法重写

  • 重写都是方法的重写,和属性无关
    -重写:需要有继承关系,子类重写父类的方法
    1. 方法名必须相同
    2. 参数列表必须相同
    3. 修饰符范围可以扩大但不能缩小:public-> protected->default->private
    4. 抛出的异常,可以被缩小但不能扩大: Clas sNotFoundException --> Exception( 大)
  • 重写子类的方法和父类的方法必须一致,方法体不同
  • 重写的意义:父类的方法子类不一定需要,或不一定满足
  • Alt+Insert:override:方法重写快捷键

多态

• 即同一方法可以根据发送对象的不同而采取多种不同的行为方式
• 一个对象的实际类型是确定的,单可以指定对象的引用类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 多态的注意事项
  1. 多态是方法的多态,属性没有多态性
  2. 不能进行多态的关键字生命的方法
     1. static 方法,属于类,他不属于实例
     2. final 常量
     3. private 私有方法
• instanceof (类型转换)引用类型,判断一个对象是什么类型

static关键字使用

• 用static关键字修饰的变量随着类生成而生成,并且只生成一次,所有new出来的对象共用这个static的变量

public class StaticDemo {
   static int s1;
   int s2;

    public static void main(String[] args) {
        StaticDemo staticDemo1 = new StaticDemo();
        StaticDemo staticDemo2 = new StaticDemo();

        System.out.println(staticDemo1.s1);
        System.out.println(staticDemo1.s2);
        System.out.println(staticDemo2.s1);
        System.out.println(staticDemo2.s2);
        System.out.println("=====================================");
        staticDemo1.s1=10;
        staticDemo1.s2=20;
        staticDemo2.s2=30;
        //staticDemo1.s1和staticDemo2.s1是static修饰的变量他们两个用的同一块内存所以数据一样
        System.out.println(staticDemo1.s1);//10
        System.out.println(staticDemo1.s2);//20
        System.out.println(staticDemo2.s1);//10
        System.out.println(staticDemo2.s2);//30

    }

• 使用static关键字修饰的代码块会在new之后第一个执行且整个系统周期内只执行一次

public class StaticDemo {
    //匿名代码块
    {
        System.out.println("匿名代码块");
    }
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
    //构造器方法
    public StaticDemo() {
        System.out.println("构造器方法");
    }

    public static void main(String[] args) {
        StaticDemo staticDemo1 = new StaticDemo();
        System.out.println("==============================");
        StaticDemo staticDemo2 = new StaticDemo();
    }
}

• 静态导入包中的方法

import static java.lang.Math.random;//静态导入包中的方法
public class StaticDemo {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

抽象类和接口

抽象类abstract

• abstract修饰符可以用来修饰方法也可以修饰类如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类
• 抽象类可以没有抽象方法,但有抽象方法的类一定声明为抽象类
• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的
• 抽像方法,只有方法的声明,没有方法的实现,它是用来让子类实现的
• 子类继承抽象类,那么姐必须实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类
• 注意
  1. 不能new这个抽象类,只能靠子类去实现它:约束
  2. 抽象类中可以写普通方法
  3. 抽象方法比须在抽象类中
  4. 抽象的抽象:约束

public abstract class Abstract {//抽象类
    public abstract void state();//抽象方法
   /* 抽象方法:只有方法名没有方法体,要靠他的子类去实现这个方法,就像是他爸没有实现的愿望交给他儿子实现一样,他儿子也没有实现(子类没有实现这个方法也要在类前加上abstract 关键字)就交给孙子就好了
   */
}

接口

• 普通类 : 只有具体的实现
• 抽象类 : 具体实现和规范(抽象方法)都有
• 接口 : 只有规范
• 接口就是规范,定义的一组规则
• 接口的本质就是契约,就像是人间的法律一样,制定好后大家都遵守
• OO的精髓是对对象的抽象,最能提现这一点的就是接口
• 声明类的关键字是class,声明接口的关键字是interface
• 作用
  1. 约束
  2. 定义一些方法,让不同的人实现
  3. public abstract(定义方法默认)方法都是抽象的
  4. public static final (默认的)只能定义静态常量
  5. 接口不能被实例化,接口中没有构造方法
  6. implements可以实现多个接口
  7. 必须重写接口中的方法
  8. 接口中不能实现方法

//interface 定义的关键字,接口都需要实现类
public interface Interface {
    //接口中的定义都是抽象的: public abstract
    void add(String name);
    void delete(String name);
    void alter(String name);
    void check(String name);
}

public interface Timer {
    void setTime(int time);
}

//实现类的名称结尾都需要用:Impl结尾,代表实现接口类
//implements 接口可以实现多继承
public class RealizeImpl implements Interface,Timer{
    @Override
    public void setTime(int time) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void alter(String name) {

    }

    @Override
    public void check(String name) {

    }
}

内部类及OOP实战

内部类

• 一个java类中可又有多个class类,但只能有一个public class
• 内部类就是在一个类的内部再定义一个类,比如:A类中定义一个B类,那么B类相对A类来说就是内部类,二A类相对B类来说就是外部类

1. 成员内部类
   • 可以获得外部类的私有属性
2. 静态内部类
3. 局部内部类
4. 匿名内部类