面向对象（二）

十四、代码块

　　静态代码块

　　　　随着类的加载而执行,只会执行一次

　　构造代码块

　　　　每次创建对象都会执行，用于初始化所有构造方法都必须初始化的数据

　　局部代码块

　　　　局部代码块执行完之后会被立马认为是垃圾

　　静态代码块,构造代码块,构造方法的执行顺序　　　

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

十五、继承

　　概述

　　　　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承这个新定义的类即可。
　　　通过extends关键字可以实现类与类的继承
　　　被继承的这个类称为父类，基类或者超类
　　　继承的类可以称为子类或者派生类。
　　　有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。

　　格式

　　　　class 子类名 extends 父类名 {}

　　优点

　　　　　提高了代码的复用性
　　　　多个类相同的成员可以放到同一个类中
　　　　提高了代码的维护性
　　　　如果功能的代码需要修改，修改一处即可
　　　　让类与类之间产生了关系，是多态的前提
　　　　其实这也是继承的一个弊端：类的耦合性很强

　　特点

　　　　　Java只支持单继承，不支持多继承。
　　　　一个类只能有一个父类，不可以有多个父类。
　　　　class SubDemo extends Demo{} //ok
　　　　class SubDemo2 extends Demo1,Demo2...//error
　　　　Java支持多层继承(继承体系)
　　　　class A{}
　　　　class B extends A{}
　　　　class C extends B{}

　　注意事项

　　　　　子类只能继承父类所有非私有的成员
　　　　子类不能继承父类的构造方法，但是可以通过super()关键字去访问父类构造方法。
　　　　不要为了部分功能而去继承

　　继承中成员变量的关系

　　　　　在子类方法中访问一个变量
　　　　首先在子类局部范围找
　　　　然后在子类成员范围找
　　　　最后在父类成员范围找
　　　　如果还是没有就报错。

　　super关键字

　　　　　super的用法和this很像
　　　　　　this代表本类对应的引用。
　　　　　　super代表父类存储空间的标识(可以理解为父类引用)
　　　　用法(this和super均可如下使用)
　　　　　　访问成员变量
　　　　　　　　this.成员变量 super.成员变量
　　　　　　访问构造方法(子父类的构造方法问题讲)
　　　　　　　　this(…) super(…)
　　　　　　访问成员方法(子父类的成员方法问题讲)
　　　　　　　　this.成员方法() super.成员方法()

　　继承中构造方法的关系

　　　　　子类中所有的构造方法默认都会访问父类中空参数的构造方法
　　　　因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
　　　　每一个构造方法的第一条语句默认都是：super()

　　　　如果父类中没有默认空参构造方法，子类通过super去显示调用父类其他的带参的构造方法
　　　　子类通过this去调用本类的其他构造方法
　　　　本类其他构造也必须首先访问了父类构造
　　　　一定要注意：
　　　　　　super(…)或者this(….)必须出现在第一条语句上

　　继承中成员方法的关系

　　　　通过子类对象去访问一个方法
　　　　　　首先在子类中找
　　　　　　然后在父类中找
　　　　　　如果还是没有就报错。

　　继承中成员方法重写

　　　　方法重写概述
　　　　　　子类中出现了和父类中一模一样的，也被称为方法覆盖，方法复写。
　　　　使用特点：
　　　　　　如果方法名不同，就调用对应的方法
　　　　　　如果方法名相同，最终使用的是子类自己的
　　　　方法重写的应用：
　　　　　　当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

　　继承中成员方法重写注意事项

　　　　父类中私有方法不能被重写
　　　　子类重写父类方法时，访问权限不能更低
　　　　父类静态方法，子类也必须通过静态方法进行重写。(没有方法重写的特性，多态中证明)

　　final关键字

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

　　单例设计模式

　　　　1、饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。

　　　　　　public Simple(){
　　　　　　　　private static Single s=new Single();
　　　　　　　　private Single(){

　　　　　　　　}
　　　　　　　　public static Simple getSimple(){
　　　　　　　　return s;
　　　　　　　　}
　　　　　　}

　　　　2、懒汉式：当程序第一次访问单件模式实例时才进行创建。

　　　　　　class Single{
　　　　　　　　private static Single s = null;

　　　　　　　　public Single() {
　　　　　　　　if (s == null)
　　　　　　　　　　s = new Single();
　　　　　　　　　　return s;
　　　　　　　　　}
　　　　　　　}

十六、多态

　　概述

　　　　某一个事物，在不同环境下表现出来的不同状态。

　　多态前提和体现

　　　　有继承关系
　　　　有方法重写
　　　　有父类引用指向子类对象

　　成员访问特点

　　　　成员变量
　　　　　　编译看左边，运行看左边
　　　　成员方法
　　　　　　编译看左边，运行看右边
　　　　静态方法
　　　　　　编译看左边，运行看左边
　　　　所以静态方法不能算方法的重写

　　多态的好处

　　　　提高了程序的维护性(由继承保证)
　　　　提高了程序的扩展性(由多态保证)

　　多态的弊端

　　　　不能访问子类特有功能

　　向上转型

　　　　从子到父
　　　　父类引用指向子类对象

　　向下转型

　　　　从父到子
　　　　父类引用转为子类对象

十七、抽象类

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

　　格式：

　　　　abstract class 类名 {}
　　　　public abstract void eat();

　　抽象类的成员特点

　　　　成员变量
　　　　　　可以是变量
　　　　　　也可以是常量
　　　　构造方法
　　　　　　有构造方法，但是不能实例化
　　　　构造方法的作用
　　　　　　用于子类访问父类数据的初始化
　　　　成员方法
　　　　　　可以有抽象方法 限定子类必须完成某些动作
　　　　　　也可以有非抽象方法 提高代码复用性

　　抽象类特点

　　　　抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
　　　　抽象类不能实例化
　　　　按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
　　　　抽象类的子类
　　　　要么是抽象类
　　　　要么重写抽象类中的所有抽象方法

十八、接口

　　接口用关键字interface表示

　　格式：

　　　　interface 接口名 {}

　　接口成员特点

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

　　接口特点

　　　　接口不能实例化
　　　　按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。
　　　　类实现接口用implements表示
　　　　格式：class 类名 implements 接口名 {}
　　　　接口的子类
　　　　要么是抽象类
　　　　要么重写接口中的所有抽象方法

　　类和接口以及彼此之间的关系

　　　　类与类
　　　　　　继承关系，只能单继承，但是可以多层继承
　　　　类与接口
　　　　　　实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
　　　　接口与接口
　　　　　　继承关系，可以单继承，也可以多继承

　　抽象类和接口的区别

　　　　成员区别
　　　　　　抽象类 变量,常量; 抽象方法;抽象方法,非抽象方法
　　　　　　接口 常量;抽象方法
　　　　关系区别
　　　　　　一个类只能继承一个抽象类
　　　　　　一个类可以实现多个接口
　　　　设计理念区别
　　　　　　抽象类 共性功能
　　　　　　接口 扩展功能

　　总结：

　　　　1.一个类可以实现多个接口，但却只能继承最多一个抽象类。
　　　　2.抽象类可以包含具体的方法，接口的所有方法都是抽象的。
　　　　3.抽象类可以声明和使用字段，接口则不能，但接口可以创建静态的final常量。
　　　　4.接口的方法都是public的，抽象类的方法可以是public，protected，private或者默认的default；
　　　　5.抽象类可以定义构造函数，接口却不能。

十九、包

　　概述：

　　　　其实就是文件夹

　　作用：

　　　　对类进行分类管理

　　包的划分：

　　　　不同的包，装不同功能的类

　　包的定义格式和注意事项

　　　　定义包的格式
　　　　　　package 包名;
　　　　　　多级包用.分开即可
　　　　注意事项：
　　　　　　package语句必须是程序的第一条可执行的代码
　　　　　　package语句在一个java文件中只能有一个
　　　　　　如果没有package，默认表示无包名

　　带包的类的编译和运行

　　　　手动式

　　　　　　javac编译当前类文件。
　　　　　　手动建立包对应的文件夹。
　　　　　　把a步骤的class文件放到b步骤的最终文件夹下。
　　　　　　通过java命令执行。注意了：需要带包名称的执行
　　　　　　java 包名.类名

　　　　自动式

　　　　　　　　javac编译的时候带上-d即可
　　　　　　　　javac -d . 源文件名.java
　　　　　　　　通过java命令执行。和手动式一样
　　　　　　　　java 包名.类名

　　导包概述

　　　　不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

　　导包格式

　　　　import 包名;
　　　　注意：
　　　　　　这种方式导入的是到类的名称。

　　权限修饰符

　　　　　　　　　　

二十、内部类

　　概述

　　　　把类定义在其他类的内部，这个类就被称为内部类。
　　　　举例：在类A中定义了一个类B，类B就是内部类。
　　　　内部类的访问特点：
　　　　　　内部类可以直接访问外部类的成员，包括私有。
　　　　　　外部类要访问内部类的成员，必须创建对象。

　　内部类分类

　　　　按照内部类在类中定义的位置不同，可以分为如下两种格式：
　　　　成员位置(成员内部类)
　　　　局部位置(局部内部类)

　　访问成员内部类里面的成员

　　　　成员内部类的常见修饰符
　　　　　　private 为了保证数据的安全性
　　　　　　static 为了让数据访问更方便
　　　　外界访问内部类非静态成员
　　　　　　外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
　　　　　　对象名.成员;
　　　　外界访问静态内部类非静态成员
　　　　　　外部类名.内部类名 对象名 = new 外部类名.内部类名();
　　　　　　对象名.成员;
　　　　外部访问静态内部类静态成员
　　　　　　外部类名.内部类名 对象名 = new 外部类名.内部类名();
　　　　　　对象名.成员;
　　　　　　　　或
　　　　　　外部类名.内部类名.成员；

　　局部内部类

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

　　类和其组成可以用的修饰符

　　　　外部类：
　　　　　　public，默认修饰符，final，abstract
　　　　　　我们自己定义：public居多
　　　　成员变量和成员内部类：
　　　　　　四种权限修饰符，final，static
　　　　　　我们自己定义：private居多
　　　　局部变量和局部内部类
　　　　　　final
　　　　构造方法：
　　　　　　四种权限修饰符
　　　　　　我们自己定义：public 居多
　　　　成员方法：
　　　　　　四种权限修饰符，final，static，abstract
　　　　　　我们自己定义：public居多

　　匿名内部类

　　　　就是内部类的简化写法。
　　　　前提：存在一个类或者接口
　　　　这里的类可以是具体类也可以是抽象类。
　　　　格式：
　　　　　　new 类名或者接口名() {重写方法;}
　　　　本质：
　　　　　　是一个继承了类或者实现了接口的子类匿名对象