2、面向对象

一、面向对象

• 定义：面向对象是基于面向过程的。

• 面向对象与面向过程比较：
  面向过程：面向过程是以函数为基础，完成各种操作。强调的是过程。
  面向对象：面向对象是以对象为基础，完成各种操作。强调的是对象，结果。

• 思想特点：
  a:是一种更符合人们思考习惯的思想
  b:可以将复杂的事情简单化
  c: 将程序员从执行者转换成了指挥者

• 类与对象的关系：
  a:类就是对现实生活中事物的描述
  b:对象就是这类事物，实实在在存在的个体

• 定义类
  其实定义类就是在描述事物，就是在定义事物的属性和行为，属性对应类中的成员变量，行为对应类中的成员方法

• 对象的初始化过程：
  a：把.class文件加载到内存。(类加载器)
  b：在栈内开辟一个变量空间。给P使用。
  c：new Person()就会在堆内存开辟空间。
  d：方法进方法区，有类名做标记。同时成员变量进堆内存并给出了默认初始化值。
  e：对成员变量进行显示初始化
  f：如果有构造代码块，可以在构造代码块中对成员变量赋值。
  g：执行构造方法中对成员变量的赋值。
  h：到此为止，对象初始化完毕。
  i：把堆内存对象的首地址值赋值给栈内存的变量。

• 成员变量和局部变量的区别
  a定义位置
  成员变量定义在类中方法外；
  局部变量定义在方法中或方法的形式参数上；
  b初始化的区别
  成员变量有默认的初始化值
  局部变量没有默认的初始化值，要先赋值才能使用
  c存储位置
  成员变量存于堆内存中，随着类的加载而加载
  局部变量存于栈内存中，随着方法的调用而加载
  d变量查找规则
  首先在局部位置找,如果有就是用,如果没有就在成员位置找,有就是用,没有就在父类中找.父类中没有就报错.

• java中参数传的问题
  基本数据类型：形式参数的改变对实际参数没有影响；其传递的是值
  引用数据类型：形式参数的改变直接影响实际参数，其传递的是地址值

• 匿名对象
  a应用场景当对象只使用一次的时候可以考虑使用匿名对象，这样写比较简单。
  b匿名对象可以当做实际参数进行传递,方法的形式参数位置不光可以传递八种基本数据类型.也可以传递引用数据类型

二、封装（Encapsulation）

• 封装的定义:
  隐藏对象的属性及实现细节仅对外提供公共的访问方式(private 仅仅是封装的一种体现形式)
• 封装的好处
  将变化隔离，提供公共的访问方式，是因为可以在访问方式中加入逻辑判断语句，对访问的数据进行操作，提高代码的健壮性。
• 封装代码体现
  a关键字private：
  表示私有的意思,它是一个访问权限修饰符,它可以修饰成员变量以及成员方法,被他修饰的成员在其他类中不能直接访问.
  b构造方法：
  1、构造方法格式及特点：
  a：方法名要与类名一致
  b：没有返回值类型
  c：没有具体的返回值
  2、 构造方法的作用：
  给对象进行初始化
  3、 给成员变量赋值
  a：通过set方法给成员变量赋值(推荐使用set)
  b：通过构造方法也可以对成员变量赋值
  set方法它的存在就是为了给成员变量赋值
  构造方法的存在主要目的是初始化对象(它可以捎带脚给成员变量赋值)
  对象一建立，就会调用与之对应的构造函数。
  4、注意事项
  a：如果你没有给出构造方法的话,系统会默认给出一个无参构造
  b：假如你给出了构造方法,那么系统将不再提供默认构造方法
  c：构造方法也可以重载(其实就是参数列表不同
• 代码块
  a:局部代码块
  概念:把它定义在方法中
  作用:可以让局部代码块中的数据尽可能早的消失,提高内存利用率.
  b:构造代码块
  概念:定义在类中方法外
  作用:可以把构造方法中共性内容定义在构造代码块中，给对象初始化。对象一建立就会运行，而且先于构造函数执行。
• static 关键字
  1、被 static 关键字修饰成员的特点
  a：随着类的加载而加载
  b：优先于对象而存在
  c：可以直接用类名.成员变量名 所调用
  2、 什么情况下使用静态呢?
  如果某个内容是被该类下所有对象所共享的那么就应该应 static 修饰
  如果这个属性是这个类下对象特有的描述时 ，不能使用静态.
  3、 static 的注意事项
  a:在静态方法中是没有this关键字的(因为this关键字是创建对象的时候才存在的,而静态的方法是随着类的加载而加载的)
  b:静态的方法只能调用静态的成员变量以及成员方法，非静态方法既可以掉用静态，也可以调用非静态方法和成员变量。
  c:静态修饰的成员变量以及成员方法可以使用类名调用也可以使用对象调用.
  4、static利与弊
  利：对对象的共享数据进行单独空间存储，节省空间，没有必要每个对象都存储一份，
  弊：生命周期过长，访问出现局限性。
• 实例变量与类变量
  a:存放位置
  类变量随着类的加载而存于方法区中
  实例变量随着对象的加载而存于堆内存中
  b:生命周期
  类变量的生命周期最长，随着类的消失而消失
  实例变量生命后期随着对象的消失而消失

三、继承

• 继承概述及特点
  a格式：A extends B(){}
  b继承的好处:提高代码的复用性;让类与类之间产生关系,是多态的前提.
  c继承的特点:java中的类只支持单继承不支持多继承(但是支持多层继承)
  d通过继承子类可以直接访问父类的非私有成员(包括成员变量以及成员方法)

• 什么时候定义继承关系
  A 如果他们有一种 A is a B的一种关系那么就适合定义继承
  注意:不要为了部分功能而去定义继承

• 子父类间成员变量的使用
  1、类的组成
  a：构造方法
  b：成员变量
  c：成员方法
  2、通过子类访问一个成员变量的时候查找规则是怎样的
  a：首先在子类的局部位置找 有就用
  b：在子类的成员位置找 有就用
  c：在父类的成员位置找
  d：父类成员位置没有就报错

• this和super的区别和应用
  a： 概述
  this :代表的是本类对象的引用
  super :代表的是父类内存空间的标识(可以理解为父类的对象引用)
  b： this 和 super 的使用
  成员变量： this.变量名 调用本类成员位置的变量
  super.变量名 调用父类成员位置的变量
  成员方法： this.方法名 调用的是本类方法
  super.方法名 调用的是父类的方法
  构造方法(写在构造方法之中)： this(参数) 调用本类中其他的构造方法
  super(参数) 调用父类中的构造方法

• 方法的重写
  1、定义
  什么是方法重写：在子父类中,方法名相同,参数列表相同,返回值类型相同(方法声明相同)
  什么是方法重载：在同一个类中,方法名相同,参数列表不同,与返回值类型无关
  2、子父类间的成员方法需要注意的地方
  a：父类中的私有方法不能被重写
  b：子类方法的访问权限修饰符要大于等于父类的访问权限修饰符
  c：静态的方法只能重写静态方法
  3、什么时候考虑使用重写
  当子类需要父类的功能,而子类又有自己特有的方法时,可以重写父类的方法
  这样既可以使用父类的功能又可以定义子类特有的内容.
  4、子父类间构造方法的执行顺序
  子父类中如果有 构造方法,构造代码块,静态代码块在创建对象时他们的执行顺序是怎么样的?
  执行顺序: 父静态代码块->子静态代码块->父构造代码块->父构造方法->子构造代码块->
  子构造方法
  5、注意
  为什么父类的构造会在子类之前执行?
  a:因为子类的构造方法中第一行会默认有一个super()会调用父类的无参构造.
  b:因为可以用子类对象调用父类中的非私有成员,那么必然要对父类进行初始化
  c:如果在构造方法中手动给出 this() 或 super()的话这两个代码一定是第一行有效代码.
  如果父类中没有无参的构造方法，那么，子类的super()就调用不到父类的构造了肿么办？
  a:可以在子类中手动给出 super(参数)来访问父类的带参构造
  一个类的构造方法第一行一定有个super(),假如说这个类没有继承的话,那么super()访问的是谁呢?
  a:访问的是Object类中的构造方法.
  当创建多个对象的时候静态代码块只执行一次(class字节码文件对象只加载一次的前提下)

• 子类如何使用父类的私有成员变量
  如果成员变量被私有了，那么，在子类中怎么使用呢？
  子类不能直接去使用父类的私有成员
  如果子类想要访问父类私有成员的话 只能通过get和set方法或者 用父类的带参构造赋值

• final关键字
  修饰类:不能被继承
  修饰成员变量:就变成了一个常量
  修饰成员方法:不可以被重写

四、多态

• 定义
  可以理解为事物存在的多种体现形态

• 多态的前提条件:
  a：要有继承关系
  b；要有方法的重写
  c：要有父类的引用指向子类对象

• 多态利与弊
  利：多态的出现大大提高了程序的扩展性和可维护性
  弊 :父类引用无法使用子类特有功能（解决办法：向下转型）

• 引用类型：
  向上转型:小到大 Animal a=new Cat();
  向下转型:大到小 Cat c=(Cat)a;

• 多态中的成员特点
  a：成员变量 :编译看父类(看程序会不会报错,如果父类有这个变量就不报错),运行看父类(这个程序运行的结果是谁)
  b：成员方法 :编译看父类(看程序会不会报错,如果父类有这个方法就不报错),运行看子类(这个程序调用的方法是谁)
  c：在多态中，成员变量的特点，无论编译还是运行都看父类，因为方法有重写而变量没有

五、抽象类

• 抽象类概述
  a:抽象类:类用关键字 abstract 修饰
  b:抽象方法:方法声明要用 abstract修饰， 方法没有方法体
  c:抽象类不能被实列化（用new创建对象），而是通过多态创建子类对象去实例化.

• 抽象类的成员特点
  a：成员变量:既有变量也有常量
  b：构造方法:有构造方法（作用：初始化父类的成员,以便给子类使用.）
  c：成员方法:有抽象方法也有非抽象方法
  注：
  抽象类中的抽象方法,是为了强制要求子类实现某些功能
  抽象类中的非抽象方法,是为了提高代码的复用性,让子类继承的

• 子类继承抽象类注意事项
  a:子类继承抽象类,子类必须重写父类的所有抽象方法
  b:要么子类也定义为抽象类

• 抽象关键字abstract不可以和哪些关键字共存？
  final: 被final修饰的方法不能被重写,而抽象方法最终都是要被重写.
  static: 如果一个方法被static 修饰那么这个方法就可以直接用类名.调用(这个方法是没有方法体的这样做没有意义)
  private: 被 private 修饰的方法在子类中是看不见的,所以这个抽象方法也是不能被重写的.

六、接口

• 概述
  a、当抽象类中的方法都是抽象的，那么该类可以通过接口的形式表现出来
  b、用interface定义接口
  c、用implements实现接口，格式：class 类名 implements 接口

• 接口的基本特点
  a：接口不能实例化
  b：接口中的方法,要么被子类重写,要么把子类也定义为抽象类或者接口

• 接口的成员特点
  a：成员变量:接口中只有常量(因为接口中的变量有默认修饰符 public static final)
  b：构造方法:接口中没有构造方法(接口中的常量是static修饰 接口中的方法没有方法体)
  c：成员方法:接口中只有抽象方法(因为接口中的 方法有默认修饰符 public abstract)

• 接口的思想特点
  a：接口是对外暴漏的原则。
  b：接口是程序对外的功能扩展。
  c：接口的出现降低耦合性。
  d：接口可以用来多实现。

• 类与接口的关系
  a：类与类的关系
  是继承关系(只能单继承,但是可以多层继承 )
  b：类与接口的关系
  是实现关系(一个类在继承一个类的同时还可以实现多个接口)
  c：接口与接口的关系
  继承关系(可以单继承也可以多继承,因为接口直接不会出现方法调用不明确的情况)
  d：类与抽象类的关系
  继承关系

• 抽象类和接口的区别
  a:抽象类:
  成员变量:可以是变量，也可以是常量。
  构造方法:有构造方法。
  成员方法:可以是抽象方法，也可以是非抽象方法。
  b:接口:
  成员变量:只能是常量。 默认修饰符 public static final
  构造方法:无构造方法
  成员方法:只能是抽象方法。 默认修饰符 public abstract
  c:类与类的关系
  继承关系。而且只能单继承，可以多层继承。
  d:类与接口的关系
  实现关系。可以单实现，也可以多实现。并且还可以在继承一个类的同时，实现多个接口。
  e:接口与接口的关系
  继承关系。可以单继承，也可以多继承。

• 抽象类和接口应该如何定义?
  抽象类里面定义的是这个体系的共性内容
  (可以把一模一样的方法定义为实体方法,把叫法一样但是实现的过程不一样的方法定义为抽象方法)

• 接口中定义的是扩展功能

七、内部类

• 定义：将一个类定义在另一个类内部,那么这个类就可以成为内部类(嵌套类,内置类)

• 分类：
  成员内部类：定义在成员位置的内部类
  局部内部类：定义在方法中的类

• 访问格式
  a：当内部类定义在外部类的成员为上，而且非私有，可以在外部其他类中建立内部类对象。
  格式：外部类名.内部类名 变量名= 外部类对象.内部类对象；
  b：当内部类在成员位置上，可以被如下修饰符所修饰：
  1、 private 修饰是为了考虑安全性
  2、 static 修饰是为了方便调用
  3、 如果成员内部类用 static 修饰那么调用的方式是，外部类名.内部类名 变量名 = new 外部类名.内部类名();
  4、局部内部类
  a局部内部类不能被静态修饰
  b可以直接访问外部类的成员，因为还持有外部类的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量
  c因为局部变量会在方法调用完毕后 消失，而局部内部类中如果有方法在用着变量， 当方法消失后，这个方法区中的内容还没有消失，也就是说这个变量还必须存在，所以为了延长生命周期，就加了final修饰
  5、内部类的访问规则
  a 内部类可以直接访问外部类
  b 外部类访问内部类，必须建立内部类的对象
  c 之所以内部类可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用： 外部类名.this
  6、匿名内部类
  a 定义：没有名字的局部内部类
  b 前提：必须存在一个类、抽象类或者接口
  c 格式：new 类名或接口名()
  d 理解：是继承了类或者实现了接口的匿名的子类对象