一、面向过程与面向对象
1.1、概念
面向过程(Procedure Oriented Programming)与 面向对象(Object Oriented Programming)
- 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
- 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
- 面向对象的三大特征
* 封装 (Encapsulation)
* 继承 (Inheritance)
* 多态 (Polymorphism)
1.2、面向对象分析问题的思路和步骤：
- 根据问题需要，选择问题所针对的现实世界中的实体。
- 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
- 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
- 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
二、面向对象的两个要素类和对象
类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
面向对象程序设计的重点是类的设计；类的设计，其实就是类的成员的设计
2.1、类和类的成员
1.1 类的成员
Java中常见的类的成员有：
- 属性：成员变量、field、字段
- 方法：成员方法、函数、method
1.2 类的语法格式
修饰符 class 类名 {
属性声明;
方法声明;
}
说明：
修饰符:缺省、public
类名: 遵循大驼峰命名规范
属性名、方法名: 遵循小驼峰命名规范
类的正文要用{ }括起来
public class Person{
private int age ; //声明私有变量 age
public void showAge(int i) {
//声明方法showAge( )
age = i;
}
}
创建Java自定义类的步骤：
- 定义类（考虑修饰符、类名）
- 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
- 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）
2.2、对象的创建和使用
创建对象的语法：
类名 对象名 = new 类名();
创建类的对象 = 类的实例化 = 实例化类
对象的使用：通过对象名.对象成员的方式访问对象成员（包括属性和方法）
如果创建了一个类的多个对象，每个对象都拥有各自的一套类的成员，且互不干扰（非static）
在同一个类中的：类中的方法可以直接访问类中的成员变量。（例外：static方法只能访问static属性、static方法；非static方法可以访问static属性、static方法、非static属性、非static方法。）
同一个包下，在不同的类中：非static属性需要先创建要访问类的对象，再用对象访问类中定义的成员；static属性可以使用类名.属性的方式访问。（public、缺省、private）
2.3、类的成员之一：属性（Field）
语法格式：
修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符
常用的权限修饰符有：private、缺省、protected、public
其他修饰符：static、final
说明2：数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
说明3：属性名
属于标识符，符合命名规则和规范即可。
- 先声明，后使用
- 在方法体外，类体内声明的变量称为成员变量。
- 在方法体内部声明的变量称为局部变量。
- 当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型。
属性赋值的先后顺序- ① 默认初始化
- ② 显式初始化
- ③ 构造器中初始化
- ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
- 以上操作的先后顺序：① - ② - ③ - ④
2.4、类的成员之二：方法（Method）
- 方法是类或对象行为特征的抽象，用来完成某个功能操作。
- 将功能封装为方法的目的是，可以实现代码重用，简化代码。
- Java里的方法不能独立存在，所有的方法必须定义在类里。
1. 方法的声明
方法的声明格式：
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝
其中：
修饰符：public,缺省,private, protected等
返回值类型：
没有返回值：void。
有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。
注意：
- 方法通过方法名被调用，且只有被调用才会执行。 方法被调用一次，就会执行一次
- 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
- 定义方法时，方法的结果应该返回给调用者，交由调用者处理。 方法中只能调用方法或属性，不可以在方法内部定义方法。
2.方法的重载(Overload)
重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
- 属于同一个类、方法名相同、参数列表不同。
3.可变个数的形参
说明：
- 声明格式：方法名(参数的数据类型 … 参数名)（jdk5.0新增） 或 方法名(参数数据类型[] 参数名)
- 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
- 可变个数形参的方法与同名的方法之间，彼此构成重载
- 可变参数方法的使用与方法参数部分使用数组是一致的
- 方法的参数部分有可变形参，需要放在形参声明的最后
- 在一个方法的形参位置，最多只能声明一个可变个数形参
4. 参数的传递
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
- 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
- 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
2.5、类的成员之三：构造器（Constructor）
1. 构造器的特征与作用
- 构造器名与类名相同，不声明返回值类型。
- 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
- 构造器的作用：①创建对象；②给对象进行初始化
2. 构造器语法格式
修饰符 类名 (参数列表) {
初始化语句；
}
注 意：
- Java语言中，每个类都至少有一个构造器
- 默认构造器的修饰符与所属类的修饰符一致
- 一旦显式定义了构造器，则系统不再提供默认构造器
- 一个类可以创建多个重载的构造器
- 父类的构造器不可被子类继承
构造器重载：
- 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。
- 构造器重载，参数列表必须不同
6. 类的成员之四：代码块
代码块(或初始化块)的作用：对Java类或对象进行初始化
代码块(或初始化块)的分类：一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块 (static block)；没有使用static修饰的，为非静态代码块。
static代码块通常用于初始化static的属性静态代码块：用static 修饰的代码块
- 可以有输出语句。
- 可以对类的属性、类的声明进行初始化操作。
- 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
- 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
- 静态代码块的执行要先于非静态代码块。
- 静态代码块随着类的加载而加载，且只执行一次。
非静态代码块：没有static修饰的代码块
- 可以有输出语句。
- 可以对类的属性、类的声明进行初始化操作。
- 除了调用非静态的结构外，还可以调用静态的变量或方法。
- 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
- 每次创建对象的时候，都会执行一次。且先于构造器执行。
2.7、类的成员之五：内部类
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类(Inner Class)，后者称为外部类(Outer Class)。
【分类】
- 成员内部类（static成员内部类和非static成员内部类）
- 局部内部类（不谈修饰符）、匿名内部类
【成员内部类特点】
- 内部类的名字不能与包含它的外部类类名相同。
- 与外部类不同，内部类还可以声明为private或protected。
- 内部类可以调用外部类的结构
- 内部类可以声明为static的，但此时就不能再使用外层类的非static的成员变量；
- 可以在内部定义属性、方法、构造器等结构
- 可以声明为abstract类 ，因此可以被其它的内部类继承
- 可以声明为final的
- 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）
【注意】
- 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
- 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
- 成员内部类可以直接使用外部类的所有成员，包括私有的数据
- 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态
【如何使用局部内部类】
- 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
- 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型
【局部内部类的特点】
- 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
- 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
- 局部内部类可以使用外部类的成员，包括私有的。
- 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
- 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
- 局部内部类不能使用static修饰，因此也不能包含静态成员
【匿名内部类】
- 匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
格式：
new 父类构造器（实参列表）|实现接口(){ //匿名内部类的类体部分 }匿名内部类的特点
- 匿名内部类必须继承父类或实现接口
- 匿名内部类只能有一个对象
- 匿名内部类对象只能使用多态形式引用
2.8、接口(Interface)
接口(interface)是抽象方法和常量值定义的集合。
- 有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
- 有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
- 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。
接口的特点：
- 用interface来定义。
- 接口中的所有成员变量都默认是由public static final修饰的。
- 接口中的所有抽象方法都默认是由public abstract修饰的。
- 接口中没有构造器。
- 接口采用多继承机制。
- 一个类可以实现多个接口，接口也可以继承其它接口。
- 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
- 接口的主要用途就是被实现类实现。（面向接口编程）
- 与继承关系类似，接口与实现类之间存在多态性
- 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。
Java 8中，你可以为接口添加静态方法和默认方法。
静态方法：静态方法使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。
默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。
若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。（解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突；可以使用
接口名.super.方法名的方式调用指定接口中的方法）若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。
三、面向对象的特性
3.1、封装性
目的：实现 “高内聚，低耦合”。
- 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合 ：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
- 隐藏一个类中不需要对外提供的实现细节；
- 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
- 便于修改，增强代码的可维护性；
Java权限修饰符public、protected、(缺省)、private置于类的成员定义前，用来限定对象对该类成员的访问权限。
Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
3.2、继承性
1、作用和格式
- 继承的出现减少了代码冗余，提高了代码的复用性。
- 继承的出现，更有利于功能的扩展。
- 继承的出现让类与类之间产生了关系，提供了多态的前提。
格式：
class A extends B{}
- A:子类、派生类、subclass
- B:父类、超类、基类、superclass
- 一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
- 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
2.、继承的规则
- 子类不能直接访问父类中私有的(private)的成员变量和方法。
- Java只支持单继承和多层继承，不允许多重继承；一个子类只能有一个父类，一个父类可以派生出多个子类
注意：- 不要仅为了获取其他类中某个功能而去继承
- 子类继承了父类，就继承了父类的方法和属性。
- 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
3、方法的重写（Override）
定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
要求：
- 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
- 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
- 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限；子类不能重写父类中声明为private权限的方法
- 子类方法抛出的异常不能大于父类被重写方法的异常
- 注意： 子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法
3.3、多态性
①理解多态性：可以理解为一个事物的多种形态。
② 何为多态性：对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
③ 多态的使用：虚拟方法调用 ；有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
④ 多态性的使用前提： ① 类的继承关系 ② 方法的重写
⑤ 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
1、instanceof 操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型。
- 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
- 如果x属于类A的子类B，x instanceof A值也为true。
2、对象类型转换 (Casting )
基本数据类型的Casting：
- 自动类型转换：小的数据类型可以自动转换成大的数据类型，如long g=20; double d=12.0f
- 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型，如 float f=(float)12.0; int a=(int)1200L
对Java对象的强制类型转换称为造型
- 从子类到父类的类型转换可以自动进行
- 从父类到子类的类型转换必须通过造型(强制类型转换)实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型
3.4、包装类
- 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
- 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
基本数据类型包装成包装类的实例 —装箱
- 通过包装类的构造器实现：int i = 500; Integer t = new Integer(i);
- 通过字符串参数构造包装类对象：Float f = new Float(“4.56”);
Long l = new Long(“asdf”);//NumberFormatException获得包装类对象中包装的基本类型变量 —拆箱
- 调用包装类的.xxxValue()方法：Boolean a = new Boolean(ture);boolean b = a.booleanValue();
- JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
字符串转换成基本数据类型
- 通过包装类的构造器实现：int i = new Integer(“12”);
- 通过包装类的parseXxx(String s)静态方法：Float f = Float.parseFloat(“12.1”); 基本数据类型转换成字符串
- 调用字符串重载的valueOf()方法：String fstr = String.valueOf(2.34f);
- 更直接的方式：String intStr = 5 + “”
四、关键字
1.this关键字
- 它在方法内部使用，即这个方法所属对象的引用；
- 它在构造器内部使用，表示该构造器正在初始化的对象
- this 可以调用类的属性、方法和构造器
1. 使用 this 调用属性、方法、构造器
- 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。
- 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
- 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
- this可以作为一个类中构造器相互调用的特殊格式，this(形参列表)
注意：
- 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
- 构造器中不能通过"this(形参列表)"的方式调用自身构造器
- 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
- "this(形参列表)"必须声明在类的构造器的首行！
- 在类的一个构造器中，最多只能声明一个"this(形参列表)"
2. super关键字
在Java类中使用super来调用父类中的指定操作：
- super可用于访问父类中定义的属性
- super可用于调用父类中定义的成员方法
- super可用于在子类构造器中调用父类的构造器
注意：
- 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
- super的追溯不仅限于直接父类
- super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
- 子类中所有的构造器默认都会访问父类中空参数的构造器
- 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行
- 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
3. static关键字
使用范围：
- 在Java类中，可用static修饰属性(类变量)、方法、代码块、内部类
被修饰后的成员具备以下特点： - 随着类的加载而加载
- 优先于对象存在
- 修饰的成员，被所有对象所共享
- 访问权限允许时，可不创建对象，直接被类调用
- 类变量（类属性）由该类的所有实例共享
- 不用创建对象就可以访问静态成员；访问方式：类名.类属性，类名.类方法
- 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
- 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super )
- static修饰的方法不能被重写
4. final关键字
在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
- final标记的类不能被继承。提高安全性，提高程序的可读性。
- final标记的方法不能被子类重写。
- final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
- final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。
- static final：全局常量
5. abstract关键字
- 用abstract关键字来修饰一个类，这个类叫做抽象类。
- 用abstract来修饰一个方法，该方法叫做抽象方法；抽象方法：只有方法的声明，没有方法的实现，以分号结束。比如：public abstract void method();
- 含有抽象方法的类必须被声明为抽象类。
- 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
- 不能用abstract修饰变量、代码块、构造器；
- 不能用abstract修饰私有方法、静态方法、final的方法、final的类。
6. import、package关键字
1. package关键字
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：package
顶层包名.子包名 ;
- 包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
- 包通常用小写单词标识。通常使用所在公司域名的倒置：com.atguigu.xxx 包的作用：
- 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
- 包可以包含类和子包，划分项目层次，便于管理
- 解决类命名冲突的问题
- 控制访问权限
JDK中主要的包介绍
- java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能
- java.net----包含执行与网络相关的操作的类和接口。
- java.io ----包含能提供多种输入/输出功能的类。
- java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
- java.text----包含了一些java格式化相关的类
- java.sql----包含了java进行JDBC数据库编程的相关类/接口
- java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
2. import关键字
为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
- 语法格式：import 包名. 类名;
注意：
- 在源文件中使用import显式的导入指定包下的类或接口
- 声明在包的声明和类的声明之间。
- 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 可以使用java.util.* 的方式，一次性导入util包下所有的类或接口。
- 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
- 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的 是哪个类。
- 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
- import static组合的使用：调用指定类或接口下的静态的属性或方法
193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
