面向对象编成的特点:封装性,继承性,多态性
类的声明格式：
[public] [abstract | final] class 类名 [extends 父类名] [implements interfaceNameList]{
//类体
}
*修饰符：可选参数，用于指定类的访问权限，可选值为public,abstract,final
*如果省略[extends 父类名],则该类继承Object类,Object类为所有类的根类,所有类都直接或间接继承Object类.
成员变量的声明格式：
[public | protect | private] [static] [final] [transient] [volatile] type 变量名;
*static：可选，用于指定该成员变量为静态变量，可以直接通过类名访问。如果省略该关键字，则表示该成员变量为实例变量。
*final：修饰符用于声明变量，该变量不能被修改。
*transient：可选，用于指定该成员变量为暂时性变量，用于对象存盘
*volatile：可选，用于指定该成员变量为共享变量，用于并发线程的共享。
成员方法的声明格式：
class 类名{
[public | protected | private] [static] [final |abstract] [native] [synchronized] type 方法名(参数列表)[throws 抛出异常列表]{
//方法体
}
}
*final | abstract不能同时修饰方法，final修饰的方法不能在子类中被覆盖，abstract用来修饰抽象方法，抽象方法必须在子类中被实现。
*native修饰的方法，称为“本地方法”，本地方法调用平台本地代码，不能实现跨平台。
*synchronized修饰的方法是同步的，当多线程方式同步方法时，只能串行地执行，保证线程是安全的。
*包定义语法格式：package pkg1[.pkg2[.pkg3...]];
*包引入语法格式：
import package1[.package2...].(类型名|*);
“包名.类型名”形式只引入具体类型，可以提高程序的可读性，“包名.*”采用通配符，表示引入这个包下所有的类型。
*常用包：
1.java.lang包：包含了Java语言的核心类，如Object、Class、String、包装类和Math等，还有包装类Boolean、Character、Integer、Long、Float和Double。使用java.lang包中的类型，不需要显式使用import语句引入，它是由解释器自动引入。
2.java.io包：提供多种输入/输出流类，如InputStream、OutputStream、Reader和Writer。还有文件管理相关类和接口，如File和FileDescriptor类以及FileFilter接口。
3.java.net包：包含进行网络相关操作的类，如URL 、Socket和ServerSocket等。
4.java.util包：包含一些实用工具类和接口，如集合、日期和日历相关类及接口。
5.java.text包：提供文本处理、日期格式化和数字格式化等相关类及接口。
6.java.awt和javax.swing包：提供了java图形用户界面开发所需要的各种类和接口。java.awt提供了一些基础类和接口，javax.swing提供了一些高级组件。
***封装: 是指隐藏对象的属性和实现细节，仅仅提供对外的公共访问方式。
构造方法
特点：没有返回值，名称要与本类的名称相同
在构造方法中可以为成员变量赋值，当实例化一个本类的对象时，相应的成员变量也将被初始化，使用this关键字可以调用类的成员变量和成员方法，还可以调用类的构造方法
*注意事项:
1.如果我们没有提供任何形式的构造方法，那么系统将提供一个无参数的构造方法
2.如果我们提供了一个带参的构造方法，那么系统将不再提供默认的无参的构造方法
3.如果我们提供了一个带参数的构造方法，由于系统不再提供无参构造，所以我们需要手动添加一个无参构造
4.构造方法可以允许以重载的方式来提供多个构造方法的存在的
5.只可以在无参构造方法中的第一句使用this调用有参构造方法
*private:私有的,可以修饰成员变量和成员方法，被private修饰的变量或者方法只能够在本类中进行访问，其他类无效
*给私有成员变量赋值的两种方式:
a.setXXX
b.构造方法
JavaBean:
1.类必须是公共的、具体的
2.必须提供一个无参构造方法
3.隐藏实现细节和成员属性，对外提供公共的方式
static的特点:
1.可以修饰成员变量和成员方法
2.随着的类加载而加载
3.他的出生时机要优先对象
4.可以被所有类的对象共享
static的注意事项：
1.在静态方法是不能存在this关键字的
如何理解?
静态是随着类加载而加载，this是随着对象的创建而加载
静态的加载时机要优先于对象的
2.静态方法只能访问静态的成员变量和成员方法
静态方法:
成员变量:只能访问静态的成员变量
成员方法:只能访问静态的成员方法
非静态方法:
成员变量:可以是静态的，也可以是非静态的
成员方法:可以是静态的，也可以是非静态的
final修饰局部变量的问题:
基本类型:基本数据类型的值不能发生改变
引用数据:则代表该类型的地址值不能发生改变，而不是对象的值不能改变
***继承:
概述：把多个类中相同的内容给提出来定义到一个独立的类当中
创建子类格式： [修饰符] class 子类名 extends 父类名{}
好处:
A.提高了代码的复用性
B.提高了代码的可阅读性
C.提高了代码的维护性
D.让类于类之间产生了联系,他是实现多态的前提
类与类之间产生了联系，其实也是继承最大的弊端：类于类之间的耦合度增强了
开发的原则:高内聚 低耦合
高内聚:每个一个类能够独立完成工作的能力
低耦合:类于类之间的联系度
Java中继承特点:
A.Java支持单根继承，不支持多根继承
B.Java支持多层继承(继承体系)
Java继承的注意细节:
A.子类只能继承父类的非私有成员(成员方法和成员变量)
B.子类不能继承父类的构造方法，但是可以通过super([参数列表])去访问父类的构造
C.千万不要因为部分功能而去使用继承（使用继承体系应该遵循一个"is a"的原则）
继承中成员变量的关系:
a.子类的变量名和父类的变量名不一致时，各自找各自的
b.子类和的变量名和父类的变量名一致时：
1.先在子类局部中去寻找，有就使用
2.先在子类成员中去寻找，有就使用
3.在去父类的成员位置，有就使用，没有就报错
this和super的区别：
this代表是本类对象的引用
super代表父类存储空间的标识(能够直接调用父类的成员数据)
a.调用成员变量
this.成员变量 调用的是本类的成员变量
super.成员变量 调用的是父类的成员变量
b.调用构造方法
this() 调用的是本类的构造方法
super() 调用的是父类的构造方法
c.调用成员方法
this.成员方法 调用的是本类的成员方法
super.成员方法 调用的是父类的成员方法（被调用的父类型的成员方法可以是静态的，也可以是非静态的）
继承中构造方法的关系:
a.子类中的所有构造方法，都会默认访问父类的无参构造。
b.为什么要访问?
因为子类继承父类会使用到父类的数据，所以子类必须先访问父类的
无参构造，以便将父类的数据进行初始化。
子类对象调用方法的时候：先找子类本身，然后再去找父类
注意:子类的构造默认的第一句代码是super();
方法重写:子类当中出现了和父类当中声明一模一样的方法
方法重载:本类当中，方法名相同，参数列表不同，与返回值无关
方法重写的应用:
当子类需要父类的功能，而功能的主体又不能满足子类的需求，可以重写父类的方法
如果不写super，那么父类的所有功能将会被覆盖。
如果写上super,那么既沿袭了父类的功能，又能扩展子类的功能。
方法重写的注意事项:
1.父类的私有方法不能被重写
2.子类的访问权限不能低于父类
3.父类如果是静态方法，子类也必须重写父类的静态方法(这个其实算不上方法重写)
4.子类必须覆盖父类中声明为abstract的方法
5.子类不能覆盖父类中声明为final或者static的方法
***多态：
概述：同一个对象，在不同时刻体现出来的不同状态。
多态的前提:
a.要有继承关系
b.要存在方法的重写（方法重写不是多态必须的）
c.要有父类的引用指向子类的对象
Fu fu = new Zi();
用代码的实现下多态:
多态中成员访问的特点:
a.成员变量
编译期，看左边，运行期看左边
b.成员方法
编译期，看左边，运行期看右边
c.构造方法
创建子类对象的时候，先访问父类构造，对父类的数据进行初始化
d.静态方法
编译期，看左边，运行期看左边
除了成员方法，其余全部看左边，因为成员方法存在方法重写，重写会覆盖父类，所以运行看子类就可以了
多态的好处:
a.提高了代码的可维护性(继承来体现)
b.提高的代码的扩展性(由多态来体现)
多态的弊端：不能使用子类的特有的功能。
解决此弊端： a.直接创建子类对象即可(但是不合适也不合理。而且非常耗内存)
b.把父类引用直接强制转换为子类引用(向下转型)
ClassCastException:类型转换失败异常，一般只出现在多态向下转型过程中
*在进行对象的向下转型之前，必须首先发生对象向上转型，否则将出现对象转换异常。
对象向上转型：父类 父类对象 = 子类实例;
对象向下转型：子类 子类对象 = (子类)父类实例;
抽象类
特点:
a. 抽象类和抽象方法必须用abstract来修饰。抽象类当中可以没有抽象方法，有抽象方法的类，一定是抽象类
b.抽象类修饰词只能为public,protected或省略
c.抽象类是不能够实例化的
1.因为它不是一个具体的存在
2.抽象类有他的构造方法，虽然不能示例化，但是需要他的构造方法去访问父类的初始化数据
d.抽象类的子类
1.如果你不想重写父类的抽象方法，该子类必须是一个抽象类
2.如果你需要重写父类的所有抽象方法，这个是时候，子类可以是一个具体的类
e.抽象方法不是一个具体的存在，不能定义任何功能，连花括号也没有
f.抽象类的实例化依靠子类来实现，这个也是多态的实现方式
抽象类的成员特点:
成员变量:有，可以是常量也可以是变量
构造方法:有，用于访问父类的初始化数据
成员方法:有，可以是抽象的，也可以是非抽象的
抽象类的成员方法的特征:
A.抽象方法，强制限制子类必须要完成的功能，不能使用private或static关键字修饰
B.非抽象方法，子类可以继承该方法，提高代码的复用性
单例设计模式:
1.可以避免程序过多的建立该类对象，其他程序无法通过其他渠道来创建对象
2.可以无限的节省内存空间，保证了该对象的唯一性(地址)
//懒汉式
public class LanHanShi {
private LanHanShi(){}
private static LanHanShi lan=null;
public static LanHanShi getLanhan() {
if(lan==null) {
lan =new LanHanShi();
}
return lan;
}
}
//饿汉式
public class ErHanShi {
private ErHanShi(){}
private static ErHanShi er=new ErHanShi();
public static ErHanShi getErHanShi(){
return er;
}
}
内部类
外部类可以是static的，也可用public,default,protected和private修饰，而外部类只能使用public和default修饰.
创建内部类对象格式：
外部类名 外部类对象 = new 外部类名();
外部类名.内部类名 内部类对象 = 外部类对象.new 内部类名();
产生外部类对象的引用 外部类名.this
对于不具有静态属性的实名内部类，如果它的成员域具有静态属性，则必须同时具有(final)最终属性
*成员内部类：
1.不能存在任何static的变量和方法
2.依附于外部类的，所以只有创建了外部类才能够创建内部类
*静态内部类：
1.创建时不需要依赖于外部类
2.不能使用任何外部类的非static成员变量和方法
3.不能含有具有静态属性的成员方法
创建静态实名内部类的实例对象格式：
new 外部类名.实名内部类名(构造方法的调用参数列表)
如果该语句在外部类的构造方法中可省”外部类名.”
*局部内部类：
1.方法或作用域中的内部类没有访问修饰符，即方法或作用域中的内部类对包围它
方法或作用域之外的任何东西都不可见。
2.方法或作用域中的内部类只能够访问该方法或作用域中的局部变量，而且这些局部变量一定要是final修饰的常量。
*匿名内部类：
1. 匿名内部类后面的分号不可缺少
2. 匿名内部类没有访问修饰符
3. new匿名内部类时，这个类首先要存在
4. 被匿名内部类使用的方法的形参必须用final修饰
5. 匿名内部类没有构造方法
创建匿名类之前，首先声明匿名类的接口，否则编译提示找不到匿名类
直接实例化接口对象：new A(){}
接口本身是不能直接进行实例化的，所以在接口实例化之后要有一个大括号，用于实现接口中的抽象方法
接口
定义接口格式：interface 接口名 {}
类实现接口格式：class 类名 implements 接口名 {}
接口不能实例化,按照多态的方式来进行实例
接口的子类
a.可以是抽象类，但是一般不用 没有任何意义
b.可以是具体类，但是必须重写接口的所有方法
由此可见:
a.具体类多态(几乎不用)
b.抽象类多态(比较常用)
c.接口多态(用的非常非常非常多)
接口成员的特点:
成员变量:只能够是常量，不存在变量(而且还是用static修饰的)
成员方法:只能是抽象方法，默认:public abstract void 类名();
构造方法:没有构造方法
所有的类都会默认地访问一个叫做Object的类，也是说，Java中所有的类都继承自Object类，Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
类与类：继承关系，只能单继承，但是可以多层继承
类与接口：实现关系，可以单实现，多实现，还可以在继承一个类的同时实现多个接口
接口与接口：继承关系，可以单继承，也可以多继承
形式参数:
基本数据类型:要的其实就是实际参数
引用数据类型:
类名:需要的其实是该类的对象
抽象类:需要的其实是该抽象类的具体子类对象
接口:需要的其实是该接口的实现类对象
返回值类型:
基本数据类型:返回基本数据类型对应的数据值
引用数据类型:
类名:返回的其实是该类的对象
抽象类:返回的其实是该抽象类的具体子类对象
接口:返回的其实该接口的实现子类对象