面向对象基础概念

事物：属性 行为 类：成员变量 成员方法 构造方法

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

对象：是该类事物的具体表现形式。具体存在的个体。

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

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

面向对象特征：封装(encapsulation)、继承(inheritance)、多态(polymorphism)

创建对象：类名 对象名 = new 类名();

使用成员变量：对象名.变量名；

使用成员方法：对象名.方法名(...)；

引用类型：数组、类、接口

形式参数是基本类型的调用：不影响实际参数

形式参数是引用类型的调用：直接影响实际参数

形式参数参数是一个类类型，需要的是该类的对象

匿名对象 ：就是没有名字的对象。 好处：匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

匿名对象应用场景：1.调用方法，仅仅只调用一次的时候。2.匿名对象可以作为实际参数传递

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。new 类名（）；

private:被其修饰的成员只能在本类中访问、是一个权限修饰符、可以修饰成员变量和成员方法。

private应用：1成员变量用private修饰2、用getxxx（）和setxxx（）访问

this：是当前类的对象的引用 （地址）、代表当前类的一个对象、哪个对象调用带this的方法，这个this就代表这个对象。

this应用场景：解决成员变量和局部变量名相同时的场景

变量的使用规则：就近原则

构造方法：给对象的数据（成员变量和成员方法）进行初始化 。格式：方法名和类名相同、没有返回值类型、没有具体的返回值

构造方法格式：public 类名() {}

构造方法的注意事项:A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。

给成员变量赋值有两种方式：A:setXxx()B:构造方法

变量什么时候定义为成员变量：如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。

变量的范围是越小越好。因为能及时的被回收。

static的特点：随着类的加载而加载、优先于对象存在、被类的所有对象共享、可以通过类名调用、也可以通过对象名调用。

静态修饰的内容一般我们称其为：与类相关的，类成员

什么时候使用静态?如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

static关键字注意事项：在静态方法中是没有this关键字的，静态是随着类的加载而加载，this是随着对象的创建而存在。

静态方法只能访问静态的成员变量和静态的成员方法

main方法的格式：public static void main(String[] args) {...}

public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。

static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。

void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。

main:是一个常见的方法入口。我见过的语言都是以main作为入口。

String[] args:这是一个字符串数组。值去哪里了?这个东西到底有什么用啊?怎么给值啊?这个东西早期是为了接收键盘录入的数据的。

格式是：java MainDemo hello world java

在同一个文件夹下，多个类定义在两个文件和定义在一个文件中其实是一样的

测试类的作用：创建其他类的对象，调用其他类的功能。

把构造方法私有，外界就不能在创建对象了

如何制作一个说明书呢?
A:写一个工具类
B:对这个类加入文档注释

/**
* 这是针对数组进行操作的工具类
* @author 二蛋
* @version V.01
*/

/**
* 获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1
* @param arr 被查找的数组 
* @param value 要查找的元素
* @return 返回元素在数组中的索引，如果不存在，返回-1
*/
C:用工具解析文档注释
javadoc工具
D:格式
javadoc -d 目录 -author -version ArrayTool.java

目录：就可以写一个文件夹的路径

制作帮助文档出错：
找不到可以文档化的公共或受保护的类：告诉我们类的权限不够

如何使用帮助文档：

1:打开帮助文档

2:点击显示，找到索引，看到输入框

3:知道你要找谁?以Scanner举例

4:在输入框里面输入Scanner，然后回车

5:看包

java.lang包下的类不需要导入，其他的全部需要导入。

要导入：

java.util.Scanner

6:再简单的看看类的解释和说明，别忘了看看该类的版本

7:看类的结构

成员变量字段摘要

构造方法构造方法摘要 

成员方法 方法摘要

8:学习构造方法

A:有构造方法就创建对象

B:没有构造方法成员可能都是静态的

9:看成员方法

A:左边

是否静态：如果静态，可以通过类名调用

返回值类型：人家返回什么，你就用什么接收。

B:右边

看方法名：方法名称不要写错

参数列表：人家要什么，你就给什么；人家要几个，你就给几个

代码块：在Java中，使用{}括起来的代码被称为代码块。

根据其位置和声明的不同，可以分为

局部代码块:局部位置,用于限定变量的生命周期。

构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。

作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。

静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。

作用：一般是对类进行初始化。

代码块面试题 静态代码块,构造代码块,构造方法的执行顺序?

静态代码块 -- 构造代码块 -- 构造方法

静态代码块：只执行一次

构造代码块：每次调用构造方法都执行

继承：把多个类中相同的内容给提取出来定义到一个类中。

如何实现继承：Java提供了关键字：extends

继承格式：class 子类名 extends 父类名 {}

继承的好处：A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类之间产生了关系，是多态的前提

继承的弊端：类的耦合性增强了。

开发的原则：低耦合，高内聚。

耦合：类与类的关系

内聚：就是自己完成某件事情的能力

Java中继承的特点：A:Java只支持单继承，不支持多继承。

B:Java支持多层继承(继承体系)

继承的注意事项：A:子类只能继承父类所有非私有的成员(成员方法和成员变量)

B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。

C:不要为了部分功能而去继承

什么时候考虑使用继承：如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

类的组成：成员变量、构造方法：成员方法

继承中成员变量的关系:A:子类中的成员变量和父类中的成员变量名称不一样

     B:子类中的成员变量和父类中的成员变量名称一样

在子类方法中访问一个变量的查找顺序：a:在子类方法的局部范围找，有就使用

 b:在子类的成员范围找，有就使用

 c:在父类的成员范围找，有就使用

 d:如果还找不到，就报错。

this和super的区别? this代表本类对应的引用。

super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

this和super用法： A:调用成员变量

this.成员变量 调用本类的成员变量

super.成员变量 调用父类的成员变量

B:调用构造方法

this(...)调用本类的构造方法

super(...)调用父类的构造方法

C:调用成员方法

this.成员方法 调用本类的成员方法

super.成员方法 调用父类的成员方

继承中构造方法的关系:子类中所有的构造方法默认都会访问父类中空参数的构造方法

原因：因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

注意：子类每一个构造方法的第一条语句默认都是：super();

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?报错。

如何解决呢? A:在父类中加一个无参构造方法

B:通过使用super关键字去显示的调用父类的带参构造方法

C:子类通过this去调用本类的其他构造方法：子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

注意事项：this(...)或者super(...)必须出现在第一条语句上。

如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

继承中成员方法的关系:A:子类中的方法和父类中的方法声明不一样，

B:子类中的方法和父类中的方法声明一样，

通过子类对象调用方法：a:先找子类中，看有没有这个方法，有就使用

b:再看父类中，有没有这个方法，有就使用

c:如果没有就报错。

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：先找子类本身，再找父类。

方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。

这样，即沿袭了父类的功能（通过super关键字调用），又定义了子类特有的内容。

方法重写的注意事项A:父类中私有方法不能被重写，因为父类私有方法子类根本就无法继承

B:子类重写父类方法时，访问权限不能更低，最好就一致

C:父类静态方法，子类也必须通过静态方法进行重写

子类重写父类方法的时候，最好声明一模一样。

子类构造方法执行前默认先执行父类的无参构造方法

一个类的初始化过程：成员变量进行初始化：默认初始化、显示初始化、构造方法初始化

super()表示：先初始化父类数据，再初始化子类数据。

Override：方法重写

Overload：方法重载

由于继承中方法有一个现象：方法重写。所以，父类的功能，就会被子类给覆盖调。有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。

这个时候，针对这种情况，Java就提供了一个关键字：final

final可以修饰类，方法，变量

final特点：final可以修饰类，该类不能被继承。

final可以修饰方法，该方法不能被重写。(覆盖，复写)

final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。

常量：A:字面值常量"hello",10,true

B:自定义常量final int x = 10;

final修饰变量的初始化时机A:被final修饰的变量只能赋值一次

B:在构造方法完毕前。(非静态的常量)

多态：同一个对象(事物)，在不同时刻体现出来的不同状态。

多态的前提：A:要有继承关系。

B:要有方法重写。

C:要有父类引用指向子类对象。

父 f =  new 子();

多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。
D:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

由于成员方法存在方法重写，所以它运行看右边。

多态的好处：A:提高了代码的维护性(继承保证)

B:提高了代码的扩展性(由多态保证)

多态的弊端：不能使用子类的特有功能。

如何使用子类的特有功能： A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)

B:把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题：向上转型：Fu f = new Zi();向下转型：Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。

继承的时候：子类中有和父类中一样的方法，叫重写。子类中没有父亲中出现过的方法，方法就被继承过来了。

在java中一个没有方法体的方法为抽象方法，而类中有抽象方法该类必须为抽象类。

抽象类的特点：

A:抽象类和抽象方法必须用abstract关键字修饰

B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类

C:抽象类不能实例化，因为它不是具体的。

抽象类有构造方法，但是不能实例化，构造方法的作用是什么呢?用于子类访问父类数据的初始化

D:抽象的子类

a:如果不想重写抽象方法，该子类是一个抽象类。

b:重写所有的抽象方法，这个时候子类是一个具体的类。

抽象类的实例化其实是靠具体的子类实现的。是多态的方式。

Animal a = new Cat();

抽象类的成员特点：

成员变量：既可以是变量，也可以是常量。

构造方法：有。用于子类访问父类数据的初始化。

成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：A:抽象方法 强制要求子类做的事情。B:非抽象方法 子类继承的事情，提高代码复用性。

一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?A:可以。B:不让创建对象。

abstract不能和哪些关键字共存?private冲突 final冲突  static 无意义

分析：从具体到抽象 实现：从抽象到具体

接口的特点：

A:接口用关键字interface表示interface 接口名 {}

B:类实现接口用implements表示class 类名 implements 接口名 {}

C:接口不能实例化那么，接口如何实例化呢?按照多态的方式来实例化。

D:接口的子类  a:可以是抽象类。但是意义不大。b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

A:具体类多态(几乎没有)B:抽象类多态(常用) C:接口多态(最常用)

接口成员特点

成员变量；只能是常量，并且是静态的。默认修饰符：public static final建议：自己手动给出。

构造方法：接口没有构造方法。

成员方法：只能是抽象方法。默认修饰符：public abstract 建议：自己手动给出。

所有的类都默认继承自一个类：Object。类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

类与类：继承关系,只能单继承,可以多层继承。

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

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

抽象类和接口的区别：

A:成员区别

抽象类：成员变量：可以变量，也可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：成员变量：只可以常量

成员方法：只可以抽象

B:关系区别

类与类：继承，单继承

类与接口：实现，单实现，多实现

接口与接口：继承，单继承，多继承

C:设计理念区别

抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

引用类型作为形式参数：

类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象

抽象类:需要的是该抽象的类子类对象

接口:需要的是该接口的实现类对象

引用类型作为返回值类型：

类:返回的是该类的对象

抽象类:返回的是该抽象类的子类对象

接口:返回的是该接口的实现类的对象

链式编程：对象每次调用完毕方法后，返回的是一个对象

包： A:其实就是文件夹

B:作用 a:把相同的类名放到不同的包中 b:对类进行分类管理

包的定义:package 包名; 多级包用.分开即可

注意事项: A:package语句必须是程序的第一条可执行的代码

B:package语句在一个java文件中只能有一个

C:如果没有package，默认表示无包名

带包的编译和运行：A:手动式

a:编写一个带包的java文件。

b:通过javac命令编译该java文件。

c:手动创建包名。

d:把b步骤的class文件放到c步骤的最底层包

e:回到和包根目录在同一目录的地方，然后运行 带包运行。

B:自动式

a:编写一个带包的java文件。

b:javac编译的时候带上-d即可 javac -d . HelloWorld.java

c:回到和包根目录在同一目录的地方，然后运行 带包运行。

导包：格式：import 包名;这种方式导入是到类的名称。注意：我们用谁就导谁。

面试题：package,import,class有没有顺序关系?有。package > import > class

Package:只能有一个 import:可以有多个 class:可以有多个，以后建议是一个

内部类概述:把类定义在其他类的内部，这个类就被称为内部类。举例：在类A中定义了一个类B，类B就是内部类。

内部的访问特点：A:内部类可以直接访问外部类的成员，包括私有。B:外部类要访问内部类的成员，必须创建对象。

内部类位置：成员位置:在成员位置定义的类，被称为成员内部类。局部位置:在局部位置定义的类，被称为局部内部类。

如何直接访问成员内部类的成员。外部类名.内部类名 对象名 = 外部类对象.内部类对象;Outer.Inner oi = new Outer().new Inner();

成员内部类的修饰符：private 为了保证数据的安全性 static 为了方便访问数据注意：静态内部类访问的外部类数据必须用静态修饰。

成员内部类被静态修饰后的访问方式是:格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();Outer.Inner oi = new Outer.Inner();

局部内部类A:可以直接访问外部类的成员B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：局部内部类访问局部变量的注意事项?A:局部内部类访问局部变量必须用final修饰

B:为什么呢?局部变量是随着方法的调用而调用，随着调用完毕而消失。而堆内存的内容并不会立即消失。所以，我们加final修饰。

加入final修饰后，这个变量就成了常量。既然是常量。你消失了。我在内存中存储的是数据20，所以，我还是有数据在使用。

匿名内部类：就是内部类的简化写法。

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

格式：new 类名或者接口名(){重写方法;}

本质是什么呢?是一个继承了该类或者实现了该接口的子类匿名对象。

1:内部类和外部类没有继承关系。2:通过外部类名限定this对象

匿名内部类的本质是继承类或者实现了接口的子类匿名对象