• 面向对象思想

  • 面向对象基本概述
    面向对象是基于面向过程的编程思想。
  • 面向对象：强调的是每一个功能的步骤
  • 面向对象：强调的是对象，然后由对象去调用功能。

• 面向对象的思想特点

  • 是一种更符合我们思想习惯的思想。
  • 可以将复杂的事情简单化
  • 将我们从执行者变成了指挥者

• 面向对象开发

  • 就是不断的创建对象，使用对象，指挥对象做事。

• 面向对象设计

  • 其实就是在管理和维护对象之间的关系。

• 面向对象特征

  • 封装
  • 继承
  • 多态

• 类

是一组相关的属性和行为的集合，是一个抽象的概念

• 对象

是该类事物的具体体现。

• 如何使用

创建对象使用
如何创建对象呢？
类名 对象名 = new 类名（）；

• 成员变量和局部变量的区别

  • 成员变量在类中方法外。
  • 局部变量在方法定义中或者方法声明上。
  • 成员变量在堆内存
  • 局部变量在栈内存
  • 成员变量随着对象的创建而存在，随着对象的消失而消失
  • 局部变量随着方法的调用而存在，随着方法的调用完毕而消失。
  • 成员变量：有默认初始化值
  • 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
  • 局部变量名称可以和成员变量一样，在方法中使用的时候，采用的是就近原则。

• 匿名对象

  • 就是没有名字的对象。
    new Student().show();
  • 匿名对象作为实际对象参数传递。

• 私有变量

  • private：私有的，可以修饰成员变量和成员方法。
  • 被private修饰的成员只能在本类中访问。
  • 这就是封装

• 封装

  • 隐藏对象的属性和实现细节，仅对外提供公共访问方式。
  • 隐藏实现细节，提供公共的访问方式
  • 提高代码的复用性
  • 提高安全性
  • 原则
    将不需要对外提供的内容隐藏起来。
    把属性隐藏，提供公共方法对其访问。

• static（可以修饰成员变量，还可以修饰成员方法）

  • static的特点
    随着类的加载而加载
    优先于对象而存在
    被类的所有对象共享 列如：班级学生共用一个班级编号。
  • 可以通过类名调用，也可以用对象名调用。
  • 静态方法只能访问静态的成员变量和静态的成员方法。

• 代码块

  • 局部代码块
    局部位置，用于限定变量的生命周期。
  • 构造代码块
    在类中的成员位置，用{}括起来的代码，每次调用构造方法执行前，都会先执行构造代码块
  • 静态代码块
    在类中的成员位置，用{}括起来的代码，只不过它用static修饰了。
    只会随着类加载一次，重复加载不会出现。
    执行顺序
    静态代码块>构造代码块>构造方法

• 继承的概述

  • 多个类中存在相同属性的行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
  • 通过extend关键字可以实现类与类的继承
    class 子类名 extends 父类名{}
  • 单独的这个类称为父类，基类或超类，这多个类可以称为子类或者派生类
  • 有了继承以后，我们定义一个的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。
  • 好处
    提高了代码的复用性
    提高了代码的维护性
    类与类之间产生了关系。

• java中继承的特点：

  • Java中支持单继承，不支持多继承
    列如class Son extends Father,Mother是错误的。
  • java支持多层继承(继承体系）

• 继承的注意事项

  • 子类只能继承父类所有非私有的成员
  • 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
  • 不要为了部分功能而去继承

• 继承和构造方法的关系

  • 子类中所有构造方法默认都会访问父类中空参数的构造方法。
  • 子类中每个构造方法默认都是super（）；开头的

• 继承中的super和this

  • 子类可以通过super去显示调用父类其他的带参的构造方法
  • 子类通过this调用本类的其他构造方法
  • 注意：super和this必须出现在方法的第一条语句。

• 方法重写

  • 子类中出现了和父类一摸一样的方法声明，也被称为方法覆盖，方法重写
  • 使用特点：
    如果方法名不同， 有就调用对应的方法，如果方法名相同，最终使用的是子类自己的。
  • 注意事项
    父类中私有方法不能被重写，因为子类无法继承父类的私有方法。
  • 子类重写父类方法时，访问权限不能比父类更低。
  • 父类静态方法，子类也必须通过静态方法进行重写

• final

  • 最终的意思，用处是不让子类的方法重载覆盖掉父类的功能，只能让他使用。
  • final可以修饰类，方法和变量
  • final修饰类的特点
    这是最终类，被final修饰了之后，无法称为父类了。
  • final修饰方法的特点
    被final修饰的方法，无法被重写
  • final修饰变量的特点。
    变量就变成了常量，只能被赋值一次。

• 多态概述

  • 某一个事物，在不同时刻表现出来的不同状态。
    父类 名称 = new 子类（）；
    -##多态的前提
  • 要有继承关系
  • 要有方法重写
  • 要有父类引用指向子类对象。

• 多态中的成员访问特点

  • 成员变量
    编译看左边，运行就是父类的值。
  • 构造方法
    创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
  • 成员方法
    编译看左边，如果子类有多出的方法就报错（这也是多态的弊端），运行结果看子类的。
  • 静态方法
    编译看左边，运行也是父类

• 多态的优点

  • 提高了代码的维护性（继承保证）
  • 提高了代码的扩展行（）

• 对象间的转型问题

  • 向上转型：
    Fu f = new Zi();
  • 向下转型
    Zi() z = (Zi)f;

• 抽象类的概述

  • 一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
  • 抽象类和抽象方法必须用abstract关键字修饰
    abstract class 类名{}
    public abstract void eat（）；

• 抽象类的特点

  • 抽象类和抽象方法必须用abstract关键字修饰
  • 抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类。
  • 抽象不能实例化
    • 因为它不是具体的。
    • 抽象类有构造方法，但是不能实例化。构造方法的作用是什么呢？
    • 用于子类访问父类数据的初始化
  • 抽象的子类
    • 如果不想重写抽象方法，该子类是一个抽象类。
    • 重写所有的抽象方法，这个时候子类是一个具体的类
  • 抽象类的实例化其实是靠具体的子类实现的，是多态的方式。
  • 抽象类中的抽象方法就是强制要求子类必须重写，也就是强制子类做的事情。

• 抽象类中的小问题

  • 一个类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义。
    • 可以
    • 意义是不让创建对象，只能通过子类访问
  • abstract不能和哪些修饰方法时的关键字共存
    • private 冲突
    • final 冲突
    • static 无意义

• 接口概述

为了体现事物功能的扩展性，java中就提供了接口来定义这些额外功能，并不给出具体实现。

• 接口的特点

  • 接口用interface表示
  • 类实现接口用implements表示
  • 接口不能实例化
    • 按照多态的方式来实例化
  • 接口多态是多态中最常用的。

• 接口成员的特点

  • 成员变量：只能是常量，并且是静态的。
    默认修饰符public、static、final
    建议是自己动手给出变量的值。
  • 构造方法
    接口没有构造方法。
  • 成员方法
    只能是抽象方法。
    默认修饰符：public abstract
    建议自己手动给出。

• 抽象类和接口的区别

  • 成员区别
    • 抽象类
      成员变量可以变量，也可以常量。
      构造方法有
      成员方法可以抽象，也可以非抽象
    • 接口
      成员变量只可以常量
      成员方法只可以抽象
  • 关系区别
    • 类与类
      继承关系，能单继承，也可以多层继承。
    • 类与接口
      实现关系，可以单实现，也可以多实现。
    • 接口与接口
      继承关系，可以单继承，也可以多继承
  • 设计理念区别
    抽象类被继承体现的是is a的关系，抽象类中定义的是该继承体系的共性功能。
    接口被实现体现的是like a 的关系，接口中定义的是该继承体系的扩展功能。

• 权限修饰符

%%0I~(N6Z3{XWGOL1(KSOP9.png

• 类及其组成所使用的常见修饰符

  • 类
    • 权限修饰符：默认修饰符，public
    • 状态修饰符：final
    • 抽象修饰符：abstract
    • 用的最多的就是：public
  • 成员变量
    • 权限修饰符：private，默认的，protected，public
    • 状态修饰符：static，final
  • 构造方法
    • 权限修饰符：private，默认的，protected，public
  • 成员方法
    • 权限修饰符：private，默认的，protected，public
    • 状态修饰符：static，final
    • 抽象修饰符：abstract
  • 其他组合规则:
    • 成员变量:public static final
    • 成员方法: public static,public abstract,public final

• 内部类概述和讲解

就是把类定义在类的内部。

• 内部类可以直接访问外部类的成员，包括私有私有
• 外部类要访问内部类的成员，必须创建对象。
• 内部类位置
  • 成员位置：在成员位置定义的类，被称为成员内部类。
    使用 外部类名.内部类名 对象名 = new 外部类名（）.new 内部类名（）
    被静态修饰后用
    外部类名,内部类名 对象名 = new 外部类名.内部类名();
    外部类名.内部类名.方法();
  • 局部位置：在局部位置定义的类，被称为局部内部类。
    局部可以直接访问外部类的成员
    在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能。
    局部内部访问局部变量必须用final修饰局部变量
    因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没用立马从堆内存中消失，还要使用那个变量。为了让数据还能据继续被使用，就用final修饰。