一、面向对象编程
（一）、面向对象
1、 面向对象的概念
万物皆对象，面向对象是以属性和行为的观点去分析现实生活中的事 物。
面向对象编程指的是先以面向对象的思想进行分析，然后用编程语言进行表达的过程。
2、 类和对象
对象主要是指现实生活中客观存在的实体，在Java语言中对象表现为内存空间中的一块存储区域。
类简单来说就是“分类”,是对具有相同特征和行为的多个对象共性的抽象描述，在java语言中表现为一种引用数据类型，里面包含了描述特征，属性的成员变量以及描述行为的成员方法。
类是用于构建对象的模板， 对象的数据结构由定义它的类来决定。
（二）、类的定义
1、类包含了描述特征的成员变量，描述行为的成员方法。通常情况下，当 类名由多个单词组成时，要求每个单词的首字母都要的大写。
2、成员变量的定义
当成员变量由多个单词组成时，第一个单词的首字母小写，通常要求从 第二个单词起每个单词的首字母大写。成员变量若是不初始化值，它有 自己的默认初始值。
格式：数据类型成员变量名=初始值(其中=初始值通常都省略不写)
public class Person{
String name;
}
3、成员方法的定义
当成员方法名由多个单词组成时， 要求从第二个单词起每个单词首字母大写。
public class Person{
void show(){ //返回值类型成员方法名(形参列表)
System.out.println( “打印“);//成员方法体
}
}
4、 对象的创建一一通过new类名()
(1)、当一个类定义完成之后，可以使用new关键字来创建该类的对象， 这个过程叫做类的实例化。
(2)、 创建对象的本质就是在内存空间的堆中申请一块存储区域， 用于存
2、放该对象独有的特征信息。
5、 引用的定义
使用引用数据类型的变量叫做引用型变量，简称引用。引用变量主要是 用于记录对象在堆区中的内存地址信息，便于下次访问。引用变量是在 在栈内存中申请一块区域，指向对内存中的对象信息。
格式：数据类型(类名)引用变量名= new类名();
例：
Person p = new Person();
p.name;
6、 返回值类型的详解
返回值主要指的是从方法体内返回到方法体外的数据内容。
返回值类型主要指返回的数据类型，可以是基本数据类型，也可以是引 用数据类型。
若是需要返回， 在方法体中使用return关键字可以返回具体的数据内容并 结束当前方法。
若是不需要返回任何数据内容时，返回值类型则写void即可。
7、形参列表
形式参数主要用于将方法体外的数据内容带入到方法体内部。列表指的 是多个参数组成的列表。
二、方法与封装
（一)、 构造方法
1、 构造方法的基本概念
构造方法名与类名完全相同并且没有返回值类型，连void都不许有。当
个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造方法
若类中出现了构造方法，则编译器不会再提供任何形式的构造方法。
例：
public class Person{
String name;//成员变量
person(String n){//Person类中的构造方法，可用于初始化对象赋值 System.out.println(“我是构造方法”);
name=n;
}
void show(){// 自定义成员方法
System.out.println(“我是成员方法");
}
}
（二)、 方法的重载——OverLoad
1、 重载的概念
方法名相同，参数列表(参数的个数，参数的类型，参数的顺序)不同。
2、 重载作用
调用者只需要记住一个方法名就可以调用各种不同的版本，来实现不同
的功能。
（三)、 this关键字
若在构造方法中出现了this关键字，则代表当前正在构造的对象。 若在成员方法中出现了this关键字，则代表当前正在调用的对象。
this关键字的工作原理：在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.就相当于汉语中“我的”,当不同的对象 调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而 this.的方式访问的结果随之也不同。
为了代码的可读性， 一般在构造方法或者成员方法中，形参名跟成员变 量名需相同，这时赋值时需要加上this.关键字声明此时修改的当前对象的 成员变量，不然程序会以就近原则直接给当前局部变量赋值，因为变量名有歧义。
（四)、递归方式
使用递归必须有递归的规律以及退出条件。递归必须使得问题简单化而不是复杂化。
例：计算n!
public class JcTes{
int show(int n)
if(1==n)return 1;
return n*show(n- 1);
}
public static void main(String[] argS){
JcTest test = new JcTest();
int res = test.show();
}
（五)、封装
1、私有化成员变量，使用private关键字修饰。也就是让该成员变量只能 在当前类的内部使用。若是没有加private关键字可以随意访问成员变量。
2、 提供公有的get和set方法，并在方法体中进行合理值判断。使用public关键字修饰公有的方法。
三、 static关键字和继承
（一)、 static关键字
1、 简介：使用static关键字修饰的成员变量表示静态的含义，此时成员 变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共 享。该成员变量会随着的加载就已经准备好了，与是否创建对象无关。 属于对象层级意为每个对象拥有独立的一份，属于类层级意为整个类只 有一份，每个对象内部不需要单独存放。
static关键字修饰的成员可以使用引用.的方式访问，但推荐使用类名.的方
式。
2 、static关键字的使用
(1)、在非静态成员方法中既能访问非静态成员也能访问静态的成员，因为静态成员被所有对象共享。
(2)、在静态成员方法中只能访问静态成员不能访问非静态成员。因为非静态态成员属于对象层级，静态成员可以通过类名.静态成员变量的方式调用，但此时可能还没有创建对象，就会出错。
(3)、不能滥用static关键字，只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰。
(4)、若是用类名.方式访问，静态成员方法中没有this关键字，因为this是用于表示对象的。
例：
public class StaticTest{
private int cnt =1;//属于对象层级
private static int snt =2; //属于类层级
//自定义非静态成员方法，需要使用引用的方式访问
public void show(){
System.out.println("cnt=" + this.cnt);//1
System.out.println("snt =" + this.snt );//2
}
//自定义静态的成员方法， 推荐使用类名.的方式访问
public static void test(){
//报错，用类名.的方式调用，此时还没有创建对象
//去掉this也报错，因为是非静态
System.out.println("cnt=" +this.cnt);
System.out.println("snt= "+this.snt); //2
}
}
（二)、构造块和静态代码块
1、构造块：在类中直接使用{}括起来的代码块。每创建一个对象就会执行一次构造块。
2、 构造块在代码中要先于构造方法执行，若是需要执行构造方法体之前
做一些准备工作时，则可以将这个准备工作的代码写在构造块中，比如，对成员变量进行的统一初始化操作。
3、静态代码块：使用static关键字修饰的构造块。
4、 静态代码块会随着类的加载而准备就绪，它只执行一次，会先于构造块执行。 当需要在执行代码之前随着类的加载做一些准备工作时，则编写代码到静态代码块中。比如，加载数据库的驱动包。
5、若是子类继承父类，里面的执行顺序如下：
- 先执行父类的静态代码块，再执行子类的静态代码块。
- 执行父类的构造块，执行父类的构造方法体。
- 执行子类的构造块，执行子类的构造方法体。
（三)、单例设计模式
1、概念 : 在某 些特 殊场 合中 ，一个 类对外提 供且 只有 一个 对象 时, 这样的类叫做单例类, 而设 计单 例的 流程 和思想叫做单例设计模式。
2、步骤 :
(1)、私有化构造方法，使用private关键字修饰。
(2)、声明本类类型的引用指向本类类型的对象，并使用private static关键 字共同修饰。
(3)、提供公有的get方法负责将对象返回出去，并使用public static关键字
共同修饰。
public class Singleton{
//private static Singleton sin = new Singleton();//饿汉式
private static Singleton sin = null;//懒汉式
private Singleton(){};
public static Singleton getlnstance(){
//return sin;/饿汉式
if(null==sin){//懒汉式
sin=new Singleton();
}
return sin
}
}
饿汉式： 一开始就创建，如上图，就像回家很饿立马就吃饭。
懒汉式：只有方法调用的时候才创建，如上图，就像是回家很饿，但是不立马吃饭，等到实在忍不住了才吃。
（四)、 继承
1、 当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成
一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。extends关键字来表示继承关系。
2、子类不能继承父类的构造方法和私有方法， 因为构造方法必须和类名 一样，子类和父类的类名不一样，私有的方法只能在本类中访问。 私有的成员变量可以被继承，只是不能直接访问。
3、 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加 代码super()的效果。若没有加编译器会自动添加。
4、一个子类只有一个父类，但一个父类可以有多个子类。
（五) 、方法的重写——Override
1、 概念：从父类中继承下来的方法不满足子类的需求时，就需要在子类
1、中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本。
2、方法名相同，参数列表相同，返回值类型相同。方法的访问权限不能变小，可以相同或者变大
（六）、访问控制
1、常用的访问控制符
修饰符 本类 同一个包中的类 子类 其他类
public 可以访问 可以访问 可以访问 可以访问
protected 可以访问 可以访问 可以访问 不能访问
默认 可以访问 可以访问 不能访问 不能访问
private 可以访问 不能访问 不能访问 不能访问
总结：
（1）public修饰的成员可以在任意位置使用。
（2） private修饰的成员只能在本类内部使用。
（3） 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰。
（七）、final关键字
1、final可以修饰类，成员方法以及成员变量。
2、final关键字修饰类体现在该类不能被继承。
3、final关键字修饰成员方法不能被重写但可以被继承。
4、final关键字修饰成员变量必须初始化且不能改变。
5、通常使用public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范要求是所有字母都要大写，不同的单词之间采用下划线连。
如：public static final double PI = 3.14。
5、final关键字修饰的变量可以通过直接赋值初始化，构造块中初始化，构造方法体中进行动态初始化这三种方式。
四、多态
（一）、多态
1、多态的概念：多态主要指同一种事物表现出来的多种形态。如：人：学生、教师、工人、保安等。
2、多态的语法格式：父类类型 引用变量名 = new 子类类型();
Person worker = new Worker(); //子类向父类转换，自动类型转换
worker.show();
上面代码在编译阶段调用父类Person的show()方法，在运行阶段调用Worker类中的show()方法。（可以理解为披着羊皮的狼）。
3、多态的特点
（1）当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。
（2）当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接
调用子类独有的方法。
（3）对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段
调用子类重写的版本（动态绑定）
（4）对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。
4、引用数据类型之间的转换
（1）引用数据类型之间的转换方式有两种：自动类型转换 和 强制类型转换。
（2）自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也叫做向上转型。
（3）强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也
叫做向下转型或显式类型转换。
（4）引用数据类型之间的转换必须发生在父子类之间，否则编译报错。若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。为了避免上述错误的发生，应该在强转之前进行判断，格式如下：if(引用变量 instanceof 数据类型)，判断引用变量指向的对象是否为后面的数据类型
（二）、抽象类
1、抽象方法：抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。 具体格式如下：***访问权限 abstract 返回值类型 方法名(形参列表); ***如：public abstract void play();
2、**抽象类：主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。**当一个类必须存在，但是不能具体实现这时候就用抽象类。
例：
public abstract class AbstractTest{
private int num;
public AbstractTest(){};
public AbstractTest(int num){
setNum(num);
};
pulic void setNum(int num){
this.num = num;
}
public Int getNum(){
return num;
}
//自定义抽象方法
public abstract void show ();
public static void main (String[] args){
//报错，不能实例化对象
AbstractTest test = new AbstractTest();
test .getNUm();
}
}
3、抽象类和抽象方法的关系
（1）抽象类中可以有成员变量、构造方法、成员方法；
（2）抽象类中可以没有抽象方法，也可以有抽象方法；
（3）拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有
抽象方法并且使用abstract关键字修饰的类。
4、抽象类的实际意义不在于创建对象而在于被继承。当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。
5、
（1）private和abstract关键字不能共同修饰一个方法，因为子类不能继承父类的只有两种类型（私有的方法和构造方法），一旦把方法标记为私有的，不能继承更别说重写了。抽象方法如果不能被子类重写那就没什么意义了。
（2）final和abstract关键字不能共同修饰一个方法，因为final修饰的类不能被重写，可以被继承，而抽象方法就指望着重写，两者矛盾。
（3）static和abstract关键字不能共同修饰一个方法，因为抽象类不能new对象，是为了防止用new出来的对象去调用抽象方法，而抽象方法是没有方法体的，所以调用是没有意义的。
（三）、接口
1、接口里面所有的方法都是抽象方法（新特性除外，从jdk1.9开始允许接口中出现私有方法）。定义接口的关键字是interface。
2、接口的实际意义是为了弥补java中不允许多继承的缺点，但是可以改成接口这样就可以实现多个接口了。使用implements关键字表达实现关系，支持多实现。
public interface Metal{ //金属接口
public void shine();
}
public interface Money{ //金钱接口
public void buy();
}
//支持多实现
public class Gold implements Metal,Money{
public interface Metal{
public void shine(){
System.out.println("金属");
}
}
public interface Money{
public void buy(){
System.out.println("钱");
}
}
public static void main(String[] args){
//声明接口类型的引用指向实现类的对象，形成多态
Metal mt = new Gold ();
mt.shine();
Metal mn = new Gold ();
mt.buy();
}
}
3、接口和类之间的区别⭐⭐⭐⭐
（1）类与类直接使用extends关键字表达继承关系，支持单继承。
（2）类与接口之间使用implements关键字表达实现的关系，支持多实现。
（3）接口与接口之间使用extends关键字表达继承关系，支持多继承。
4、接口和抽象类的区别⭐⭐⭐⭐
（1）定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
（2）继承抽象类的关键字是extends，而实现接口的关键字是implements。
（3）继承抽象类支持单继承，而实现接口支持多实现。
（4）抽象类中可以有构造方法，而接口中不可以有构造方法。
（5) 抽象类中可以有成员变量，而接口中只可以有常量。
（6）抽象类中可以有成员方法，而接口中只可以有抽象方法。
（7）抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需
要重写（Java8以前的版本）。
（8）从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰。
（9）从Java9开始增加新特性，接口中允许出现私有方法。
五、特殊类
（一）、内部类
1、内部类的基本概念：当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部（Outer）。
类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静
态代码块、内部类。
当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个
类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以
方便的访问外部类的私有成员而不再需要提供公有的get和set方法。
2、内部类的分类
（1）普通内部类 - 直接将一个类的定义放在另外一个类的类体中。
（2）静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。
（3）局部内部类 - 直接将一个类的定义放在方法体的内部时。
（4）匿名内部类 - 就是指没有名字的内部类。
（二）、普通内部类 / 成员内部类
public class NormalOuter{
private int outer = 1;
//定义普通内部类，隶属于外部类的成员，并且是对象层级。
public class NormalInner{
private int inner = 1;
private int outer= 3;
//普通内部类的构造方法
public NormalInner(){
System.out.println("普通内部类的构造方法执行到了！");
}
//普通内部类的成员方法
public void show(){
System.out.println("外部类中outer的数值为"+outer);
System.out.println("普通内部类inner的数值为"+inner);
}
//普通内部类的成员方法
public void show2(int outer){
System.out.println("形参变量outer的数值为"+outer);
System.out.println("内部类outer的值为"+this.outer);
System.out.println("外部类outer的值为 为"+NormalOuter.this.outer);
}
}
}
public class NormalOuterTest{
public static void main(String[] args){
//声明NormalOuter类型的引用指向该类型的对象
NormalOuter outer = new NormalOuter();
//声明NormalOuter类中的内部类的引用指向内部类的对象
NormalOuter.NormalInner inner = outer.new NormalOuter();
//调用内部类中的show方法
inner.show();
System.out.println("======================");
inner.show2(4); //打印4，3，1
}
}
普通内部类的使用方式总结：
• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
• 普通内部类和普通类一样可以使用final或者abstract关键字修饰。
• 普通内部类还可以使用private或protected关键字进行修饰。
• 普通内部类需要使用外部类对象来创建对象。
• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使
用this关键字。
（三）、静态内部类
public class StaticOuter{
private int outer = 1; //隶属于对象层级
private static int snt= 2; //隶属于类层级
//定义静态内部类，隶属于类层级
public static class StaticInner{
private int inner = 3;
private static int snt= 4; //隶属于类层级
//静态内部类的构造方法
public StaticInner(){
System.out.println("静态内部类的构造方法执行到了！");
}
//静态内部类的成员方法
public void show(){
System.out.println("内部类中inner的数值为"+inner); //3
System.out.println("外部类snt的数值为"+snt);//2
//Error,静态上下文中不能访问非静态的成员，此时可能还未创建对象
// System.out.println("外部类outer 的数值为"+outer );
}
public void show2(int snt){
System.out.println("snt="+snt);//5
System.out.println("内部类中的成员snt="+StaticInner.snt);//4
System.out.println("外部类中的成员snt="+StaticOuter.snt);//2
}
}
}
public class StaticOuterTest{
public static void main(String[] args){
//声明StaticInner 类型的引用指向该类型的对象
StaticOuter.StaticInner in = new StaticOuter.StaticInner ();
//调用内部类中的show方法
in .show();
System.out.println("======================");
in .show2(5); //打印5，4，2
}
}
静态内部类的使用方式：
• 静态内部类不能直接访问外部类的非静态成员。
• 静态内部类可以直接创建对象。
• 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要
使用类名.的方式访问。
（四）、局部内部类 / 方法内部类
public class AreaOuter{
private int cnt = 1;
public void show(){
//从java8开始默认理解为定义的局部变量为为final关键字修饰的变量
int innerNum = 2; //局部变量
//定义局部内部类，只在方法体的内部好使
class AreaInner{
private int inner = 3;
//局部内部类的构造方法
public StaticInner(){
System.out.println("局部内部类的构造方法执行到了！");
}
//局部内部类的成员方法
public void test(){
System.out.println("inner="+inner);
System.out.println("cnt="+cnt);
//innerNum = 5 Error
System.out.println("innerNum="+innerNum); //2
}
}
//声明局部内部类的引用指向局部内部类的对象
AreaInner areaInner = new AreaInner();
areaInner.test();
}
}
public class AreaOuterTest{
public static void main(String[] args){
//声明局部内部类类型的引用指向该类型的对象
AreaOuter ar = new AreaOuter();
//调用内部类中的show方法
ar.show();
}
}
局部内部类的使用方式：
• 局部内部类只能在该方法的内部可以使用。
• 局部内部类可以在方法体内部直接创建对象。
• 局部内部类不能使用访问控制符和static关键字修饰符。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内
部类和局部变量的声明周期不同所致。
（五）、匿名内部类（重点）
pubic interface AnonInterface{
//自定义抽象方法
public abstract void show();
}
public class AnonInterfaceTest{
public static void test(AnonInterface an){
an.show();
}
public static void main(String[] args){
//使用匿名内部类的语法格式来得到接口类型的引用
//格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
AnonInterface anon = new AnonInterface(){
@Override
public void show(){
System.out.println("匿名内部类");
}
};
//方法二：从java8新特性可以用lamda表达式
// AnonInterface anon = ()->System.out.println("用lamda表达式获取");
AnonInterfaceTest.test(anon);
}
}
（六）、枚举类
1、概念：在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事务的所有值都可以一一列举出来，这些列举出来的类型就叫做枚举类型。如所有的性别：男，女。
//编程实现所有方向的枚举：所有的方向：向上，向下，向左，向右
public class Direction{
//用于描述方向字符串的成员变量
private final String desc;
//声明本类类型的引用指向本类类型的对象
public static final Direction UP = new Direction("向上");
public static final Direction DOWN = new Direction("向下");
public static final Direction LEFT = new Direction("向左");
public static final Direction RIGHT = new Direction("向右");
//私有化构造方法，只在本类中使用，因为若是用public外部将可以传任意值
private Direction(String desc){
this.desc = desc;
}
public String getDesc(){
return desc;
}
}
/**
测试类
**/
public class DirectiontTest{
public static void test(AnonInterface an){
Direction dr = Direction.UP;
System.out.println("方向为"+dr.getDesc());
}
}
/**
改造：从java1.5开始提供了enum关键字来定义枚举类型取代常量
**/
public class DirectionEnum{
//枚举类型要求所有枚举值必须放在最前面
UP("向上"),DOWN("向下"),LEFT("向左"),RIGHT("向右");
//用于描述方向字符串的成员变量
private final String desc;
//私有化构造方法，只在本类中使用，因为若是用public外部将可以传任意值
private Direction(String desc){
this.desc = desc;
}
//成员方法
public String getDesc(){
return desc;
}
}
2、枚举类总结：
• 使用public static final表示的常量描述较为繁琐，使用enum关键字来定
义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public
static final关键字共同修饰，因此采用枚举类型.的方式调用。
• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默
认也是私有的。
3、所有的枚举类都继承自java.lang.Enum类。
（七）、注解
1、概念：注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理。相当于日常生活中超市货架上的标签。是从Java5开始增加的一种引用数据类型。注解自动继承java.lang.annotation.Annotation接口。
2、元注解：元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。元注解主要有 @Retention、@Documented、@Target、@Inherited、@Repeatable。
3、元注解——@Retention——说明该注解的的生命周期
•RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时
它将被丢弃忽视。
• RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加
载到 JVM 中，默认方式。
• RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载
进入到 JVM 中，所以在程序运行时可以获取到它们。
4、元注解——@Documented——用于指定被该注解将被javadoc工具提取成文档，定义为@Documented的注解必须设置Retention值为RUNTIME。
5、元注解——@Target——用于指定被修饰的注解能用于哪些元素的修饰
1302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
