java面向对象总结

工作中采用的Java基本上全面鼓吹面向对象有多好，一切都是面向对象，我们所接触的各种设计模式基本上也是面向对象的设计。

面向对象—劈柴处总结

• 1||| 面向对象入门概述
  • 什么是面向对象？
    • 概述：
      • 面向对象——行为化（概念相对抽象，可结合下面的例子理解） 面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成类（类实例化后才是对象），创建了对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为
    • 思想特点：
    • 举例
    • 总结：万物皆对象
  • 了解：面向过程什么是？
    • 面向过程是：一种编程思想，强调的是过程。 代表语言有：c语言。
  • 你为什么要学习编程语言？
    • 就是把现实世界的事物通过编程语言给描述出来, 实现信息化.
    • 举例
      • A. 超时的计费
      • B. 银行OA
      • C. 千亿级数据仓
      • D. 用户画像....
  • 我们是如何描述现实世界事物的呢?
    • 属性:名词, 事物的外在特征.
    • 行为:动词, 事物能够做什么.
  • 和面向对象相关的概念
    • 1||| 类:
      • 属性, 行为的集合, 抽象, 看不见, 摸不着.
    • 2||| 对象:
    • 3||| 成员变量:
    • 4||| 成员方法:
  • 格式:
    • 类的定义格式:
      • public class 类名 { //属性 //行为 }
    • 如何使用类中的成员:
      • （1） 创建对象.
        • 类名 对象名 = new 类名();
      • （2） 通过 对象名. 的形式调用.
        • 对象名.成员变量;
        • 对象名.成员方法(参数值);
  • 了解:
    • I. 一个对象的内存图
    • II. 二个对象的内存图
    • III. 两个对象指向同一个对象的内存图
• 2||| 面向三大特性：
  • 封装:
    • 什么是封装？概述:
      • 隐藏... 公共的访问方式.
      • 怎么隐藏? 答：private对属性进行隐藏
      • 在同一个类中公共的访问隐藏属性的方式是什么？: 答：getXxx(), setXxx()
    • 好处:
      • 1. 提高代码的安全性.
        • private
          • adj. 私有的
      • 2. 复用性.
        • 方法
    • 弊端:
      • 提高了代码量.为什么呢？答：private导致的。
    • this关键字:
      • 概述: #代表 本类当前对象 的 引用. 大白话: 谁调用, this就代表谁.
      • 作用:
        • 解决 局部变量 和 成员变量 重名问题.
      • 使用变量的规则:
        • 就近原则.
    • 构造方法:
      • 概述(作用): 就是用来创建对象的, 捎带着可以给属性赋值.
      • 格式: public 类名(){ // 方法体 } 空参构造 public 类名(参数列表 ){ super(); }
      • 注意事项:
        • 1||| 我们不写空参构造方法, 系统自动补全空参构造方法.
        • 2||| 我们写了空参构造方法, 系统不给.
        • 3||| 建议: 空参, 全参，全写！
        • 4||| 构造方法可以重载.
  • 继承
    • 什么是继承？概述：
      • 好多类中, 内容, 相似. 很麻烦, 抽取, 单独类, 关系, 继承.
    • 格式:
      • public class A extends B {} //子承父业
    • 好处:
    • 弊端:
      • 耦合性增强了.
      • 扩展: 开发原则: 高内聚, 低耦合.
        • 1||| 内聚:
          • 类自己独立处理某些问题的能力...
        • 2||| 耦合:
          • 类与类之间的关系.
    • 继承的特点:
      • 只能单继承, 不能多继承.
      • 多层继承.
    • 继承关系中的成员特点:
      • 1||| 成员变量:
        • 就近原则.
      • 2||| 构造方法:
        • 1. 子类构造方法的第一行 super(), 作用是啥? 用于子类访问父类构造方法
        • 2. 父类没有空参怎么办?
      • 3||| 成员方法:
        • 就近原则.
    • 方法重写:
      • 概述: 在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。
      • 使用场景:
        • 自己概述：要沿袭父类的功能, 而功能主体又有自己独有的需求时. 大白话理解说：父类的方法体内的代码就变成了伪代码，因为 子类把父类代码体重写了。
        • 官方回答：当父类中的 方法 无法满足 子类需求 或 子类具有特有功能 的时候，需要方法重写。
      • 在重写方法时，需要遵循那些规则呢？
        • 1、参数列表必须完全与被重写的方法参数列表相同。 2、返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。 3、访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。 4、重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。
      • 另外还要注意以下几条：
        • 重写的方法可以使用 @Override 注解来标识。 父类的成员方法只能被它的子类重写。 声明为 final 的方法不能被重写。 声明为 static 的方法不能被重写，但是能够再次声明。 构造方法不能被重写。 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。 如果不能继承一个方法，则不能重写这个方法。
    • super和this的区别
      • this 指的是当前对象的引用，super 是当前对象的父对象的引用。下面先简单介绍一下 super 和 this 关键字的用法。 super 关键字的用法： super.父类属性名：调用父类中的属性 super.父类方法名：调用父类中的方法 super()：调用父类的无参构造方法 super(参数)：调用父类的有参构造方法 如果构造方法的第一行代码不是 this() 和 super()，则系统会默认添加 super()。 this 关键字的用法： this.属性名：表示当前对象的属性 this.方法名(参数)：表示调用当前对象的方法 当局部变量和成员变量发生冲突时，使用this.进行区分。 关于 Java super 和 this 关键字的异同，可简单总结为以下几条。 子类和父类中变量或方法名称相同时，用 super 关键字来访问。可以理解为 super 是指向自己父类对象的一个指针。在子类中调用父类的构造方法。 this 是自身的一个对象，代表对象本身，可以理解为 this 是指向对象本身的一个指针。在同一个类中调用其它方法。 this 和 super 不能同时出现在一个构造方法里面，因为 this 必然会调用其它的构造方法，其它的构造方法中肯定会有 super 语句的存在，所以在同一个构造方法里面有相同的语句，就失去了语句的意义，编译器也不会通过。 this( ) 和 super( ) 都指的是对象，所以，均不可以在 static 环境中使用，包括 static 变量、static 方法和 static 语句块。 从本质上讲，this 是一个指向对象本身的指针, 然而 super 是一个 Java 关键字。 例 3 在 Animal 类和 Cat 类中分别定义了 public 类型的 name 属性和 private 类型的 name 属性，并且 Cat 类继承 Animal 类。那么，我们可以在 Cat 类中通过 super 关键字来访问父类 Animal 中的 name 属性，通过 this 关键字来访问本类中的 name 属性，如下面的代码： // 父类Animal的定义 public class Animal { public String name; // 动物名字 } //子类Cat的定义 public class Cat extends Animal { private String name; // 名字 public Cat(String aname, String dname) { super.name = aname; // 通过super关键字来访问父类中的name属性 this.name = dname; // 通过this关键字来访问本类中的name属性 } public String toString() { return "我是" + super.name + "，我的名字叫" + this.name; } public static void main(String[] args) { Animal cat = new Cat("动物", "喵星人"); System.out.println(cat); } } 上述代码演示了使用 super 关键字访问父类中与子类同名的成员变量 name，this 关键字访问本类的 name 变量。运行程序，输出结果如下： 我是动物，我的名字叫喵星人
    • 例子
      • 例题一： 每种动物都有名字和年龄属性，但是喜欢吃的食物是不同的，比如狗喜欢吃骨头、猫喜欢吃鱼等，因此每种动物的介绍方式是不一样的。 下面编写 Java 程序，在父类 Animal 中定义 getInfo() 方法，并在子类 Cat 中重写该方法， 实现猫的介绍方式。父类 Animal 的代码如下： public class Animal { public String name; // 名字 public int age; // 年龄 public Animal(String name, int age) { this.name = name; this.age = age; } public String getInfo() { return "我叫" + name + "，今年" + age + "岁了。"; } } 子类 Cat 的代码如下： public class Cat extends Animal { private String hobby; public Cat(String name, int age, String hobby) { super(name, age); this.hobby = hobby; } public String getInfo() { return "喵！大家好！我叫" + this.name + "，我今年" + this.age + "岁了，我爱吃" + hobby + "。"; } public static void main(String[] args) { Animal animal = new Cat("小白", 2, "鱼"); System.out.println(animal.getInfo()); } } 如上述代码，在 Animal 类中定义了一个返回值类型为 String、名称为 getInfo() 的方法，而 Cat 类继承自该类，因此 Cat 类同样含有与 Animal 类中相同的 getInfo() 方法。但是我们在 Cat 类中又重新定义了一个 getInfo() 方法，即重写了父类中的 getInfo() 方法。 在 main() 方法中，创建了 Cat 类的对象 animal，并调用了 getInfo() 方法。输出的结果如： 喵！大家好！我叫小白，我今年2岁了，我爱吃鱼。 如果子类中创建了一个成员变量，而该变量的类型和名称都与父类中的同名成员变量相同，我们则称作变量隐藏。
  • 多态
    • 什么是多态？ 答：概述：同一个对象，在不同的时刻表现出来的不同形态。
      • 例子：狗 狗就是狗 狗 dog = new 狗(); 我们也可以说： 动物 animal = new 狗(): 这里的狗在不同的时刻·表现出不同的形态，这就是多态。
    • 多态的前提和体现
      • 
      • 1||| 有继承(extends 类)/实现(implement 接口)关系
      • 2||| 有：“方法重写”
      • 3||| 有父类引用指向子类对象。
    • 多态的访问特点：
      • 口诀： 成员变量：编译看左，执行看左。 成员方法：编译看左，执行看右。
      • 为什么成员变量和成员方法的访问不一样呢？ 这是因为 成员方法有重写，而成员变量是没有的。 大白话理解：编译看左【因为重写的是父类中的方法，检查父类中有没有此方法让子类重写】，执行看右【执行在子类中重写父类的方法！】。
    • 多态的优点和缺点
      • 优点 1、提高了程序的扩展性。 具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参数与操作
      • 缺点 不能使用子类的特有功能。
    • 多态中的的转型
      • 1.向上转型从子到父 父类引用指向子类对象
      • 2.向下转型从父到子 父类引用转为子类对象
• 3||| 抽象类(abstract)
• 4||| 接口(interface)
  • I. 接口成员特点
    • 成员变量只能是常量; 默认修饰符 public static final
    • 成员方法只能是抽象方法; 默认修饰符 public abstract
    • 接口没有构造方法; 因为接口主要对行为进行抽象,没有具体存在，一个类如果没有父类,默认继承自Object类
  • II. 类和接口的区别
    • 1||| 类和类的继承关系 (一个类只能够单继承一个父类不能够多继承n多个不同的父类)继承关系，只能单继承，但是可以多层维承
    • 2||| 类和接口的实现关系 (一个类可以实现n多个不同的接口)实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
    • 3||| 接口和接口继承的关系 (一个接口是可以继承n多个不同的接口的)继承关系，可以单继承，也可以多继承
  • III. 抽象类和接口的区别
    •  抽象类和接口的区别 举个例子:门和报警器,将门设为抽象类, 行为:关门开门警
    • 1||| 成员区别
      • A. 抽象类中成员
        • 1. 有抽象类变量常量
        • 2. 有构造方法
        • 3. 有抽象方法
        • 4. 有非抽象方法
      • B. 接口中成员
        • 1. 接口常量
        • 2. 抽象方法
        • 3. (JDK8在接口中定义非抽象方法)
    • 2||| 关系区别
      • 1. 类与类继承单继承
      • 2. 类与接口实现 单实现和多实现
        • 一对一，一对多。
      • 3. 接口与接口继承 单继承和多继承
    • 3||| 设计区别
      • 1. 抽象类对类抽象,包括属性行为(对事物的抽象)
      • 2. 接口对行为抽象,主要是行为(对行为的抽象)