1、面向对象和面向过程
1.1 概念
类（**Class**）和对象（**Object**）是面向对象的核心概念
- 类是对一类事物的描述，是从抽象的，概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例（instance）
- 万事万物皆对象
1.2 Java类及类的成员
现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。<br /> 现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java中用类class来描述事物也是如此。常见的类的成员有：<br /> **属 性**：对应类中的成员变量<br /> **行 为**：对应类中的成员方法<br />Field = 属性 = 成员变量，Method = (成员)方法 = 函数<br /><br />初级阶段一个类由属性（成员变量）和方法（函数构成）<br />后来慢慢有了构造器，内部类，代码块等等
1.3 对象的创建以使用
Java类的实例化及创建类的对象
类名 对象名 = new 类名（）；
内存解析
匿名对象
我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。
如：new Person().shout();
使用情况
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。
2、类的成员
2.1 属性
1. 语法格式
<br />**说明1:修饰符**
- 常用的权限修饰符有：private、缺省、protected、public
- 其他修饰符：static、final (暂不考虑)
说明2：数据类型
- 任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
说明3：属性名
-
2. 变量的分类
2.2 方法
1. 语法格式
说明：
修饰符：public,缺省,private, protected等
返回值类型：void 没有返回值2. 方法的分类
2.3 构造器（构造方法）
1. 构造器的特征
它具有与类相同的名称
- 它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
2. 构造器的作用
创建对象；给对象进行初始化
如：Order o = new Order(); Person p = new Person(“Peter”,15);
- 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了
3. 构造器的说明
根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供）
- 显式定义一个或多个构造器（无参、有参）
注 意：
- Java语言中，每个类都至少有一个构造器
- 默认构造器的修饰符与所属类的修饰符一致
- 一旦显式定义了构造器，则系统不再提供默认构造器
- 一个类可以创建多个重载的构造器
- 父类的构造器不可被子类继承
4. 构造器重载
构造器一般用来创建对象的同时初始化对象
构造器重载使得对象的创建更加灵活，方便创建各种不同的对象5. 内部类
2.4 总结：属性赋值的过程
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值2.5 代码块
1. 代码块的作用和分类
作用：对Java类或对象进行初始化
分类：一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)，没有使用static修饰的，为非静态代码块
static代码块通常用于初始化static的属性2. 静态代码块（用static修饰的代码块）
- 可以有输出语句。
- 可以对类的属性、类的声明进行初始化操作。
- 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
- 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
- 静态代码块的执行要先于非静态代码块。
-
3. 非静态代码块（没有static修饰的代码块）
可以有输出语句。
- 可以对类的属性、类的声明进行初始化操作。
- 除了调用非静态的结构外，还可以调用静态的变量或方法。
- 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
-
4. 程序中成员变量赋值的执行顺序
3、再谈类的成员之方法
3.1 方法的重载
1. 重载的概念
在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数和参数类型不同即可。
2.重载的作用
与返回值无关，只看参数列表，且参数列表必须不同（参数个数和参数类型）。调用时根据方法参数列表的不同来区别。
使用重载可以为方法为编程带来方便
例如：System.out.println()方法就是典型的重载。
当我们在业务中一个方法名特别适合好几个业务，我们就可以用到重载的概念了。3. 递归方法
3.2 方法的重写（override/orderwrite）
1. 定义
方法的重写运用在继承以及实现接口上。单继承，多实现
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。(继承中子类可以调用父类的属性和方法)2. 要求
子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
- 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
- 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
- 子类不能重写父类中声明为private权限的方法
- 子类方法抛出的异常不能大于父类被重写方法的异常
3. 注意
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，如果同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。4. 扩展知识-JavaBean
JavaBean是一种Java语言写成的可重用组件。
- 所谓javaBean，是指符合如下标准的Java类：
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get、set方法
- 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变
UML类图
UML 统一建模语句
- 表示 public 类型， - 表示 private 类型，#表示protected类型
- 方法的写法: 方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型
5、面向对象的三大特征
3.1 封装和隐藏
1. 封装的作用和含义
Java程序追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用。从而提高系统的可拓展性，可维护性。把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。2. model的实现原则
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()**和setXxx()**实现对该属性的操作，以实现下述目的：
- 隐藏一个类中不需要对外提供的实现细节；
- 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
- 便于修改，增强代码的可维护性；
3. 四种访问修饰符
Java权限修饰符public、protected、(缺省)、private置于类的成员定义前，用来限定对象对该类成员的访问权限。
| 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
|---|---|---|---|---|
| private | Yes | |||
| 缺省 | Yes | Yes | ||
| protected | Yes | Yes | Yes | |
| public | Yes | Yes | Yes | Yes |
对于class的权限修饰只可以用public和default(缺省)。
- public类可以在任意地方被访问。
-
3.2 继承性
1. 为什么要有继承
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
此处的多个类称为子类（派生类），单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”。2. 继承的作用
继承的出现减少了代码冗余，提高了代码的复用性。
- 继承的出现，更有利于功能的扩展。
- 继承的出现让类与类之间产生了关系，提供了多态的前提。
3. 继承的规则
- 子类继承了父类，就继承了父类的方法和属性。
- 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
- 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
子类不能直接访问父类中私有的（private）的成员变量和方法。
4. 单层继承和多层继承
Java只支持单继承和多层继承，不允许多重继承
一个子类只能有一个父类
一个父类可以派生出多个子类
多态性，是面向对象中最重要的概念，在Java中的体现：对象的多态性：父类的引用指向子类的对象
- 可以直接应用在抽象类和接口上
- Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。
- 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
- 多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法） “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
- 对象的多态 —在Java中,子类的对象可以替代父类的对象使用
- 一个变量只能有一种确定的数据类型
- 一个引用类型变量可能指向(引用)多种不同类型的对象
- 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法
2. 多态小结
- 多态作用：提高了代码的通用性，常称作接口重用
- 前提：需要存在继承或者实现关系有方法的重写
- 成员方法：编译时：要查看引用变量所声明的类中是否有所调用的方法。运行时：调用实际new的对象所属的类中的重写方法。
-
3. instanceof操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
4. 子类继承父类
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量
6、Object类的使用
6.1 Object概念
Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
6.2 主要结构
6.3 == 和equals()方法
1. 区别
**”==“**<br /> 基本类型比较值，只要两个变量的值相等，则为true<br /> 引用类型比较引用（是否指向同一个对象），只有指向同一个对象的时候，==才会返回true<br /> **"equals()"**<br /> 所有类都继承了Object，也就获得了**equals()**方法。还可以重写<br /> 只能比较引用类型，其作用与**“==”**相同,比较是否指向同一个对象 <br /> 特例：当用**equals()**方法进行比较时，对类**File**、**String**、**Date**及**包装类**（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象.<br /> 原因：<br /> 在这些类中重写了**Object**类的**equals()**方法
2. 重写equals（）方法的原则
对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
- 自反性：x.equals(x)必须返回是“true”。
- 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
- 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
- 任何情况下，x.equals(null)，永远返回是“false”
- ==既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
- equals**的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
- 具体要看自定义类里有没有重写Object的equals方法来判断。
- 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。
6.4 toString()方法
- toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
- 在进行String与其它类型数据的连接操作时，自动调用toString()方法
Date now=new Date();
System.out.println(“now=”+now);// 相当一
System.out.println(“now=”+now.toString());
- 可以根据需要在用户自定义类型中重写toString()方法如String 类重写了toString()方法，返回字符串的值。
s1=“hello”;
System.out.println(s1);//相当于
System.out.println(s1.toString());*
- 基本类型数据转换为String类型时，调用了对应包装类的toString()方法
int a=10; System.out.println(“a=”+a);
7、包装类的使用
7.1 包装类（Wrapper）
- 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
- 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象
7.2 装箱和拆箱
1. 装箱
**基本数据类型包装成包装类的实例**<br /> 通过包装类的构造器实现<br /> 还可以通过字符串参数构造包装类对象
2. 拆箱
**获得包装类对象中包装的基本类型变量**<br /> 调用包装类的.xxxValue()方法
7.3 字符串转换成基本数据类型
- 通过包装类的构造器实现
int i = new Integer(“12”);
- 通过包装类的parseXxx(String s)静态方法
Float f = Float.parseFloat(“12.1”);
7.4 基本数据类型转换成字符串
- 调用字符串重载的valueOf()方法
String fstr = String.valueOf(2.34f);
- 更加直接的方式
7.5 基本类型、包装类与String类间的转换
8、关键字
8.1 this的使用
1. this是什么
在Java中，this关键字比较难理解，它的作用和其词义很接近。
- 它在方法内部使用，即这个方法所属对象的引用；
- 它在构造器内部使用，表示该构造器正在初始化的对象。
- this 可以调用类的属性、方法和构造器
什么时候使用this关键字呢？
- 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。
- 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
- 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
3. 注意点
- 可以在类的构造器中使用”this(形参列表)”的方式，调用本类中重载的其他的构造器！
- 明确：构造器中不能通过”this(形参列表)”的方式调用自身构造器
- 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了”this(形参列表)”
- “this(形参列表)”必须声明在类的构造器的首行！
-
8.2 package、import的使用
1. package是什么
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。
- 包对应于文件系统的目录，package语句中，用.来指明包(目录)的层次；
包通常用小写单词标识。通常使用所在公司域名的倒置：com.itonghui.xxx
2. 包的作用
包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
- 包可以包含类和子包，划分项目层次，便于管理
- 解决类命名冲突的问题
-
3. MVC设计模式
MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。<br /><br />
4. JDK中主要的包介绍
1. java.lang——包含一些Java语言的核心类，如String、Math、Integer、 System和
Thread，提供常用功能
2. java.net——包含执行与网络相关的操作的类和接口。
3. java.io——包含能提供多种输入/输出功能的类。
4. java.util**——包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日
期日历相关的函数。
5. java.text——包含了一些java格式化相关的类
6. java.sql——包含了java进行JDBC数据库编程的相关类/接口
7. java.awt**——包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这
些类被用来构建和管理应用程序的图形用户界面(GUI)。5. 关键字import
为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
8.3 Static
1. static的作用
当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。
2. 类变量，类方法设计方法
类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用
3. 使用范围
在Java类中，可用static修饰属性、方法、代码块、内部类
被修饰后的成员具备以下特点：
-
5. 类方法(class method)
没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法
- 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构
- 没有创建对象也可以访问静态方法
- 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)
-
8.4 Static引出的单例设计模式
1. 何为设计模式？
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。”套路”
2. 单例（Singleton）设计模式
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
3. 实现方式—饿汉式
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single = new Singleton();
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
return single; } }4. 实现方式—懒汉式
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single;
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
if(single == null) {
single = new Singleton();
}
return single; } }5. 单例（Singleton）模式的优点
由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
6. 应用场景
- 网站的计数器，一般也是单例模式实现，否则难以同步。
- 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
- 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
- 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
- Application 也是单例的典型应用
- Windows的Task Manager (任务管理器)就是很典型的单例模式
Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
8.5 final
1. final的概述
在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
修饰类
- 被final修饰的类不能被重写，不能拥有自己的子类（被称为太监类）
- 修饰方法
- 修饰的方法不能被重写
修饰变量
用abstract关键字来修饰一个类，这个类叫做抽象类。
- 用abstract来修饰一个方法，该方法叫做抽象方法。
- 抽象方法：只有方法的声明，没有方法的实现。以分号结束
- public abstract void talk();
- 含有抽象方法的类必须被声明为抽象类。
- 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
- 不能用abstract修饰变量、代码块、构造器。
不能用abstract修饰私有方法、静态方法、final的方法、final的类。
2. 抽象类应用
抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。
- Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。
-
3. 思考？
问题1：为什么抽象类不可以使用final关键字声明？
问题2：一个抽象类中可以定义构造器吗？
问题3：是否可以这样理解：抽象类就是比普通类多定义了抽象方法，除了不能直接进行类的实例化操作之外，并没有任何的不同？10、接口
10.1 接口是什么
一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
- 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个”是不是”的关系，而接口实现则是 “能不能”的关系
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守
10.2 接口的特点
接口(interface)是抽象方法和常量值定义的集合。
- 用interface来定义。
- 接口中的所有成员变量都默认是由public static final修饰的。
- 接口中的所有抽象方法都默认是由public abstract修饰的。
- 接口中没有构造器。
-
10.3 接口的注意
定义Java类的语法格式：先写extends，后写implements
- class SubClass extends SuperClass implements InterfaceA{ }
- 一个类可以实现多个接口，接口也可以继承其它接口。
- 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
- 接口的主要用途就是被实现类实现。（面向接口编程）
- 与继承关系类似，接口与实现类之间存在多态性
- 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现
10.4 接口和抽象类之间的对比
在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口11、面向对象导图总结
若有收获，就点个赞吧
0 人点赞
