java学习(三) —— 面对对象

摘要：前言是面对对象的语言，因此有必要多带带纪录下对象的各种定义和理解。面对对象基本概述概述是基于面向过程的变成思想，是对面向过程的一种封装。面对对象开发就是不断的创建对象，使用对象，指挥对象做事情。面对对象设计其实就是在管理和维护对象之间的关系。

java是面对对象的语言，因此有必要多带带纪录下对象的各种定义和理解。

面对对象，主要包括：面向对象思想，类与对象及其使用，对象的内存图，成员变量和局部变量的区别，匿名对象，封装（private），this关键字，构造方法，static关键字。

概述：是基于面向过程的变成思想，是对面向过程的一种封装。

面对对象开发：就是不断的创建对象，使用对象，指挥对象做事情。

面对对象设计：其实就是在管理和维护对象之间的关系。

面对对象特征：封装，继承，多态

类与对象的关系：

（1）类：一组相关的属性和行为的集合
（2）对象：是该类事物的具体体现

匿名对象：

（1）就是没有名字的对象，是对象的一种简化表示形式
（2）匿名对象的两种使用情况：1、对象调用方法仅仅一次的时候 2、作为实际参数传递

Student s = new Student();在内存中做了哪些事情？

（1）加载Student.class文件进入内存
（2）在栈空间为s开辟空间
（3）在堆内存为学生对象开辟空间
（4）对学生对象的成员变量进行默认初始化
（5）对学生对象的成员变量进行显示初始化
（6）通过构造方法对学生对象的成员变量赋值
（7）学生对象初始化完毕，把对象地址赋值给s变量

类 基本包括：继承、多态、抽象类、接口、包和导包、权限修饰符、内部类

概述：多个类中存在相同属性和行为时，将这些内容抽取到多带带一个类中，那么多个类无需再定义这些属性和行为，只要继承这个类即可。

通过extends这个关键字可以实现类与类到继承

多带带的这个类称为父类或者基类、超类，这多个类可以称为子类或者派生类

有了继承后，我们定义一个类的时候，可以在一个已经存在的类的基础上，定义自己的新成员

好处：

（1）提高了代码的复用性
（2）提高代码的维护性
（3）让类与类之间产生了关系，是多态的前提
（4）类的一个弊端就是，类的耦合性很强

注意事项：

（1）子类只能继承父类所有非私有成员（成员方法和成员变量）
（2）字类不能继承父类的构造方法，但是可以通过super关键字访问父类的构造方法
（3）不要为类部分功能而去继承

继承中构造方法的关系：

（1）子类中所有的构造方法都默认会父类中空参数的构造方法
（2）因为子类会继承父类的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
（3）每一个构造方法的第一条语句默认是：super()
（4）如果父类中没有构造方法怎么办：
   【1】子类通过super去显示调用父类其他的带参的构造方法
   【2】子类通过this调用本类的其他构造方法
   【3】一定要注意，super()后者this()必须出现在第一条语句中，否则，就会有父类数据的多次初始化

方法重写：

（1）概述：子类中出现了一个和父类一摸一样的方法声明，也被称为方法覆盖，方法复写
（2）父类中的私有方法不能被重写
（3）子类重写父类方法时，访问权限不能更低
（4）父类静态方法，子类也必须通过静态方法进行重写

static关键字：

（1）可以修饰成员变量和成员方法
（2）特点：
     【1】随着类的加载而加载
     【2】优先于对象存在
     【3】被类的所有对象共享
     【4】可以通过类名调用
（3）注意事项：
     【1】在静态方法中是没有this关键字的
     【2】静态方法只能访问静态的成员变量和静态的成员方法
（4）静态变量和成员变量的区别：
     【1】静态变量属于类，所以也成为类变量；成员变量属于对象，所以也称为实例变量
     【2】静态变量存储在方法区的静态区，成员变量存储在堆内存中
     【3】静态变量随着类的加载而加载，随着类的消失而消失；成员变量随着对象的创建而存在，随着对象的消失而消失
     【4】静态变量可以通过类名调用，也可以通过对象调用；成员变量只能通过对象名调用

super关键字：

（1）super和this关键字的用法很像，this代表本类对应的引用，super代表父类存储空间的标识（可以理解为父类的引用）
（2）使用super来引用父类的成分，用this来引用当前对象

final关键字：

（1）final关键字是最终的意思，可以修饰类、成员变量、成员方法
（2）修饰类，类不能被继承
（3）修饰变量，变量就变成了常量，只能被赋值一次
（4）修饰方法，方法不能被重写

概述：某一个事物，在不同时刻表现出来的不同状态

多态的前提和体现：有继承关系，有方法重写，有父类引用直接指向子类对象

好处：

（1）提高程序的维护性（由继承保证）
（2）提高程序的扩展性（由多态保证）

弊端：不能访问子类特有功能

概述：一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

特点：

（1）抽象类和抽象方法必须是由abstract关键字修饰
（2）抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
（3）抽象类不能实例化
（4）那么，抽象类如何实例化？按照多态的方法，由具体的子类实例化
（5）抽象类的子类，要么是抽象类，要么重写抽象类中的所有抽象方法

抽象类成员特点：

（1）成员变量可以是变量，也可以是常量
（2）有构造方法，但是不能实例化。那么构造方法的作用是什么？用户子类访问父类数据的初始化
（3）可以有抽象方法，限定子类必须完成某些动作
（4）也可以有非抽象方法，提高代码复用性
（5）抽象方法必须为public或protected（因为如果是private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public

概述：英文成为interface，软件工程中，接口泛指供别人调用的方法或函数，它是对行为的抽象

接口特点：

（1）使用关键字interface表示：interface 接口名{}
（2）类实现接口用implements表示：class 类名 implements 接口名{}
（3）接口不能实现实例化，但是可以按照多态的方式，由具体的子类实例化
（4）接口的子类：要么是抽象类，要么重写接口中的所有抽象方法

接口成员特点：

（1）成员变量：只能是常量，默认修饰符是public、static、final
（2）没有构造方法，因为接口主要是扩展功能的，而没有具体存在
（3）接口的成员方法只能是抽象方法，默认修饰符是public、abstract

类与类：继承关系，只能单继承，但是可以多层继承

类与接口：实现关系，可以单实现，也可以多实现。还可以在继承一个类多同时实现多个接口

接口与接口：继承关系，可以单继承，也可以多继承

接口是对动作的抽象，抽象类是对根源的抽象

抽象类表示的是这个对象是什么，而接口表示的是这个对象能做什么

抽象类与接口都不能被实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象

抽象类要被子类继承，接口要被类实现

接口只能做方法声明，抽象类中可以做方法声明，也可做方法实现

接口中定义的变量只能是公共的静态常量，抽象类中的变量是普通变量

抽象类里边的抽象方法必须被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同理，一个实现接口的时候，如果不能全部实现接口方法，那么该类也只能是抽象类

抽象方法只能声明，不能实现。接口是设计的结果，抽象类是重构的结果

接口可以继承接口，并可继承多接口，但是类只能单继承

抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候用接口。

概述：其实就是文件夹，对类进行分类管理

定义：package 包名

注意事项:

(1)package语句必须是程序的第一条可执行的代码
(2)package语句在一个java文件中只能有一个
(3)如果没有package，默认表示无包名

带包的类的编译和运行:

（1）手动式:
   【1】javac编译当前类文件
   【2】手动建立包对应的文件夹
   【3】把编译生成的class文件放到上一步建立的文件夹下
   【4】通过java命令执行，需要带包的名称执行：java testpackage.HelloWorld
（2）自动式：
   【1】javac编译的时候带-d参数执行：javac -d .HelloWorld.java
   【2】通过java命令执行，和手动式一样

导包：

（1）概述：不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路经，比较麻烦。这时，java提供了导包功能
（2）导包格式：import 包名.类名

概述：把类定义在其他类的内部，这个类就被成为内部类

访问特点：

（1）内部类可以直接访问外部类的成员，包括私有
（2）外部类要想内部类的成员，必须创建对象

内部类位置：

（1）按照内部类在类中定义的位置不同，可以分为两种格式：成员位置(成员内部类)，局部位置(局部内部类)
（2）成员内部类：
    【1】常见修饰符：private，static
    【2】被静态修饰的成员内部类只能访问外部类的静态成员
（3）局部内部类：
    【1】可以直接访问外部类的成员
    【2】可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
    【3】局部内部类访问局部变脸必须用final修饰。因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存消失，还要使用那个变量。为了让数据还能继续被使用，就用final修饰，这样，在堆内存里面存储的其实是一个常量值。
（4）匿名内部类：
    【1】就是内部类的简化写法
    【2】格式：new 类名或接口名(){}
    【3】前提：存在一个类或者接口，这里的类可以是具体的普通的类，也可以是抽象类
    【4】本质：是一个继承了类或者实现了接口的子类匿名对象
    【5】可以说，匿名内部类其实就是一个子类匿名对象