java面向对象

Java面向对象:

  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路分析整个系统。但是，具体到微观操作，仍然需要用到面向过程的思路去处理。

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

  • Java面向对象的三大特性：

    • 封装

    • 继承

    • 多态

方法定义：

 /*
 修饰符 返回值类型 方法名(参数类型 参数值) {
     //方法体
     return 返回值；
 }
 */

  • 修饰符： public、static、final等等

  • 返回类型： viod、int、String等等

  • break：跳出switch，结束循环

  • return：结束方法

  • 方法名：

    • 命名规范

    • 见名知意

  • 参数列表：（参数类型 参数值）

  • 异常抛出

方法的调用：

  • 静态方法：修饰符加了 static的类，调用方法：类名.方法名()

  • 非静态方法：没加static的类，需要使用new实例化这个类。

  //对象类型 对象名 = 对象值
 Student student = new Student();

  • 注意：两个静态方法可以相互调用，两个非静态方法也可以直接调用，但是一个静态方法不能直接调用一个非静态方法，因为非静态方法是和类一起加载的，而静态方法是new了一个类的实例后才能使用的。

  • 形参和实参：两者的数据类型必须要一致

  • 值传递和引用传递：

    • 值传递：

    • 引用传递：传递的是一个对象，但本质上还是值传递。

  • this关键词：

类和对象的关系

  • 类：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体的事物。例如: 动物、植物、手机、电脑...

  • 对象：对象是抽象概念的具体实例。例如：张三、张三家的狗...

  • 构造器：创建了一个类以后，即使你没有构造一个方法，构造器也会给你构造一个与类名相同的，没有返回值的无参方法，new出一个类的实例后，本质上是在调用该无参方法，但是一旦在该类里手动定义了有参方法，该无参方法便会失效，如果还需要用到该无参方法，需要手动在该类中将无参方法加上，在new出这个类的对象的时候，根据有无参数传入，会选择对应的方法。

    • 特点：

      1. 和类名相同

      2. 没有返回值

    • 作用：

      1. new本质在调用构造方法

      2. 初始化对象的值

    • 注意点：

      1. 构造器快捷键Alt+Insert

      2. this. = 值 这里的值一般是参数传进来的值

封装

  • 我们程序设计要追求“高内聚，低耦合”。

    • 高内聚：类的内部数据操作细节由自己完成，不允许外部干涉；

    • 低耦合：仅暴露少量的方法给外部使用。

  • 封装(数据的隐藏)：

    • 通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这成为信息隐藏。

  • 要了解封装，记住一句话就够了：

    • 属性私有，get/set

  • 封装的好处：

    1. 提高程序的安全性，保护数据

    2. 隐藏代码的实现细节

    3. 统一接口

    4. 增加系统的可维护性

继承

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

  • extends的意思是"扩展"。子类是父类的扩展。

  • java中类只有单继承，没有多继承！

  • 继承是类和类之间的一种你关系。除此之外，类和类之间还有依赖、组合、聚合等关系。

  • 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。

  • 子类继承了父类，就会拥有该父类的全部方法。

  • 使用 Ctrl+H 快捷键可以快速观察类与类之间的继承关系

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

super

  • 注意点：

    1. super调用父类的构造方法，必须在构造方法的第一个。

    2. super必须只能出现在子类的方法或构造方法中！

    3. super和this不能同时调用构造方法。因为调用构造方法必须在方法的第一个，同时调用总有一个会报错。

    4. 使用private私有的方法，无法被继承，不能在子类中使用super调用。

  • Vs this：

    • 代表的对象不同：

      • this： 本身调用者这个对象

      • super： 代表父类对象的引用

    • 前提：

      • this：可以在非继承条件下使用

      • super：只能在继承条件下使用

    • 构造方法：

      • this(); 调用本类的构造

      • super(); 调用父类的构造

重写

重写需要有继承的关系，子类重写父类的方法！

  1. 方法名必须相同，参数列表必须相同，方法体不同。

  2. 静态方法不能重写

  3. 修饰符：范围可以扩大，但不能缩小： public>Protection>Default>private

  4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

为什么需要重写：父类的功能子类不一定要，或不一定满足！

重写快捷键： Alt + Insert ； 选override

多态

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

    • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。(父类、有关系的类)

  • 注意事项：

    1. 多态是方法的多态，属性没有多态

    2. 父类和子类，有联系， 数据转换异常：ClassCastException

    3. 存在条件：

      1. 继承关系

      2. 方法需重写(子类重写父类方法)

      3. 父类应用指向子类对象 Father f1 = new Son();

  • 不能进行多态的方法：

    1. static 方法，属于类，不属于实例

    2. final 常量

    3. private方法

  • instanceof：判断两个对象是否存在继承关系

  • (类型转换)引用类型：

    • 父类引用指向子类的对象

    • 把子类转化为父类，向上转型，有可能会丢失子类本来的一些方法。

    • 把父类转化为子类，向下转型，需要强制转换

    • 作用：方便方法的调用，减少重复的代码！简洁

static 关键字详解

  • 匿名代码块

    • 作用：赋初始值

    • 执行比构造方法早，比静态代码块晚

    • 和对象是同时产生的

  • 静态代码块：只执行一次，最先执行。

  • static加在方法前叫静态方法，加在属性前叫静态变量，对于静态变量，推荐直接使用类名进行访问 类名.静态变量名；对于静态方法，也可以直接使用类名.静态方法名直接调用。非静态方法可以直接调用静态方法，静态方法只能调用静态方法，不能调用非静态方法。

抽象类

  • 使用abstract修饰的类叫抽象类，抽象类是一种约束

  • 使用abstract修饰的方法叫抽象方法，只有方法名，没有方法的实现，可以让继承的子类来帮我们实现。

  • 要继承抽象类，必须要重写抽象方法，普通方法可以不必重写。

注意：

  1. 不能new这个抽象类，只能靠子类去实现它：约束！

  2. 抽象类中可以写普通方法。

  3. 抽象方法必须在抽象类中。

接口

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范（抽象方法）都有

  • 接口：只有规范，自己无法写方法，专业的约束！约束和现实分离：面向接口编程~

  • 声明类的关键词是class,声明接口的关键词是interface

  • 作用：

    1. 约束

    2. 定义一些方法，让不同的人来实现

    3. 接口定义的方法默认是 public abstract

    4. 接口定义的变量默认是 public static final

    5. 接口不能被实例化！ 接口中没有构造方法

    6. implements可以实现多个接口

    7. 必须要重写接口中的方法

    8. 接口可以伪多继承

内部类

  • 一个Java类中可以有多个class类，但只能有一个public class类。

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

    1. 成员内部类

      • 通过外部类实例化内部类，最大的作用是获得外部类的私有属性；当外部类和内部类存在同名属性时，直接输出属性名将会优先调用内部类里的属性，想要调用外部类的同名属性需要输出外部类名.this.属性名。建议内部类的方法调用内部类使用this.属性；调用外部类的属性使用外部类名.this.属性名。

      • 成员内部类不能定义静态成员（属性）。但是可以包含静态常量（修饰符里加final）。

    2. 静态内部类（static修饰）

      • 只有内部类才可以使用static修饰，普通的类是不可以的。

      • 静态内部类和外部类级别相同。

      • 静态内部类可以添加静态成员。

      • 调用外部类的属性，由于静态内部类和外部类级别相同，可以先new外部类对象，然后通过对象.属性访问

      • 调用静态内部类的属性和方法可以直接调用。

      • 调用静态内部类的静态属性可以使用类名.属性名。

    3. 局部内部类：在外部类的方法中定义的类

      • 作用范围和创建对象范围仅限当前方法。

      • 局部内部类前不能加任何访问修饰符。

      • 局部内部类和局部变量级别相同，可以直接通过属性名访问外部类属性。建议使用类名.this.属性名访问

      • 访问局部内部类的属性，也可以直接通过属性名访问，建议使用this.属性名

      • 想要调用局部内部类的方法，需要在外部类的方法中new一个局部内部类对象，使用对象.方法访问。

      • 局部内部类里想要访问外部类当前方法的局部变量，可以直接填局部变量名（在JDK1.7前需要把局部变量定义成final才能访问，JDK1.8时，访问局部变量时自动将局部变量定义成了final，原因是两者生命周期不同。）

    4. 匿名内部类：(没有类名的局部内部类，一切特征与局部内部类相同)

      • 必需继承一个父类或实现一个接口。

      • 可以直接new一个继承的父类或一个接口，然后重写方法使用。

posted @ 2020-08-04 17:38  20200720  阅读(104)  评论(0)    收藏  举报