Java抽象类和接口

第一节：抽象类
为什么要使用对象类？
有些类创建对象不具体，需要把这个定义为抽象类
使用abstract修饰类变成抽象类:不能被实例化，但可以被继承。
抽象类的构造方法不能直接使用，只能被子类调用

抽象类“
使用abstract关键字修饰
特点：
1）抽象类中可以包含抽象方法，也可以不包括抽象方法
2）抽象类中有构造方法，但是不能创建对象，
3）抽象类的存在就是为了被继承，子类必须重写父类的抽象方法，除非子类也是抽象类

抽象方法：
使用abstract关键字修饰，只表示声明了一个方法，但是没有任何的实现
特点：
1）没有方法体，使用分号表示方法声明结束
2）如果一个类中有一个方法是抽象的，那么这个类也必须是抽象的
3）抽象方法必须被子类重写，除非子类也是抽象类

抽象类和普通类的区别：
1）抽象类需要abstract，而普通类不需要
2）构造方法都有，但是抽象类不能实例化对象，普通类可以
3）成员方法：抽象类中可以存在抽象方法也可以存在非抽象方法，而普通类中只能存在非抽象方法

final和abstract是否可以连用？
1）final修饰的方法可以被继承不能被重写；abstract修饰的方法必须被重写，所以不能修饰同一个方法
2）final修饰的类不能被继承；abstract修饰的类必须被继承

static：
1）属性：表示类公共的属性，使用类来调用，推荐使用类调用（类名.属性名）
2）方法：表示类公共的方法，在静态方法中只能直接调用静态变量或静态方法，不能使用
this，super，如果想要调用非静态方法和属性，需要创建对象
3）代码块：静态代码块，程序一加载静态代码块就会运行，而且只运行一次

final：
1）属性，局部变量：final表示的为常量，只能赋值一次
2）方法：本方法不能被子类重写，但是被继承
3）类：本类不能被继承

abstract：
1）方法：抽象方法，该方法只有声明，没有方法体
构造方法和static方法，final方法不能是抽象的
有该方法的类称为抽象类，类名前必须加abstract
2）类：抽象类不能被实例化
抽象类可以指向子类对象的引用
抽象类可以有普通方法，可以被子类继承
父类的抽象方法必须在子类中实现，除非子类也是抽象类

第二节：接口
接口的概念：从语法上讲 接口时一种特殊的抽象类，这种抽象类只包含常量和方法的定义，没有方法的 实现
从功能上讲：接口表示一种约定（规范）或能力
接口的好处：扩展类的功能，保持对外接口一致
皆苦实现了多重继承，完成类和任何实现接口的子类的通信和交互
降低代码之间的耦合性
接口的特点：接口不能创建对象，而且接口中没有构造方法
接口中的方法一般都是共有的抽象方法：public abstract
接口中所有的属性都是共有静态常量属性”public static final

一个类可以实现多个接口，一个类如果父类也实现接口，声明类时，先继承再实现接口

接口和接口之间的关系：接口之间可以继承，用extends来实现

类之间不能实现多继承，接口之间可以实现多继承
jdk1.8以后 接口可以包含默认方法，可以被实现类继承
jdk1.8之后，接口包含静态方法 不能被继承，只能通过接口直接调用

第一节 内部类
内部类：一个类中嵌套（包含）另外一个类，包含的类叫内部类，外部的叫外部类
成员内部类：
局部内部类：
静态内部类：
匿名内部类：
1成员内部类
作为外部类的成员存在，与成员变量和成员方法平级关系
成员内部类的访问权限：任意的
创建外部类对象：Out o = new out();
通过外部类找到内部类，通过外部类对象创建内部类对象：Out.In i=o.new In();
一步到位：Out.In i = new Out().new In();
当外部类的属性和内部类属性不同名时，可以直接访问
当外部类属性与内部类属性同名时，格式：外部类名.this.属性名
生成字节码文件名：外部类名$内部类名.class

2.局部内部类
作为局部成员存在，和局部变量平级
3.静态内部类
4.匿名内部类
没有名字的内部类
原理产生原因：由于接口和抽象类不能创建对象，若一个接口的实现类只需要使用一次，或一个抽象类的子类只需要使用一次，可以使用匿名内部类，匿名内部类只能创建一个对象。
匿名内部类只能用一次，再次使用需要重新创建，即便两次声明的匿名内部类完全一次，那也是两个不同的内部类。

设计模式：就是软件开发人员再软件开发工程中面临的一般问题的解决方案。**简单理解就是特定问题的特定解决方法。
总体来说设计模式分为三大类：创建型模式，共五种
结构型模式，共七种
行为型模式，共是一种

单例模式：在程序运行中一个类只需要一个实例，不能出现过多个实例，就叫单例。
实现原理：封装
得到一个类的对象，需要通过new关键字，调用构造方法创建新的对象
第一步：私有化构造方法
第二部：在类内部创建对象
第三步：提供一个共有的方法，来获取对象
实现方法：单例分为懒汉式和饿汉式
核心：构造方法私有：不能再类外随意创建对象
在类内部声明一个本类静态的对象作为属性
提供一个共有镜头的方法用来获取本类对象
饿汉式写法
有点：不会出现线程安全问题
缺点：浪费空间，声明周期长
懒汉式写法
优点：节省空间，声明周期短
缺点：有 线程安全问题
懒汉和饿汉的去呗
语法区别：懒汉时调用方法时初始化对象，饿汉时声明同时初始化
存储空间：第一次获取单例类对象前，懒汉比饿汉节省空间
多线程操作时区别：懒汉存在线程安全问题，饿汉没有线程安全问题

2.简单工厂设计模式

面向对象的设计原则
1.总则：开闭原则：对拓展开放，对修改关闭
2.单一职责原则：不要存在多于一个导致类变更的原因，也就是说每一个类应该实现单一的职责，如若不然，就应该吧类拆分
3.里氏替换原则：是面向对象设计的基本原则之一，里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。里氏替换原则中，子类对父类的方法尽量不要重写和重载，因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它
4.依赖倒置原则：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互
5.接口隔离原则：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分，使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。
6.迪米特法则：一个类对自己依赖的类知道的越少越好，也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部，这样当被依赖的类变化时，才能最小的影响该类
7.合成服用原则：原则是尽量首先使用合成/聚合的方式，而不是使用继承。

装箱和拆箱
装箱：把基本类型转成引用类型
int a = 100
integer integer=new integer();
拆箱：把引用类型换成基本类型
int a=integer.intvalue();
jdk1.5之后自动装箱：
int count=1000;
Integer integer=count;
自动拆箱：int count2=integer;

String类
int indexof
int lastindexof
char charat(int index)
boolean contains()
boolean isEmpty
boolean startsWith
boolwan endswith
booleanen equals
string substring
string trim
static string format
int compareTo
int comparetoignorecase

StringBuffer类用在多线程中，stringbuilder类用在单线程中
1.追加 append (**.append())
2.删除delete

intern方法用来返回常量池中的某字符串，如果常量池中已经存在该字符串，则直接返回
否则，在常量池中加入该对象，然后返回引用。
intern();方法的用法
1.只在常量池上创建常量
string a1=“AA”;
2.只在堆上创建对象
string a2=new string(“A”)+new string(“B”)；
3.在堆上创建对象，在常量池上创建常量
string a3=new string(“AA”);
4.在对上创建对象，在常量池上创建引用
string a4 = new string(“A”)+new string(“A”)只在堆上创建对象AA
a4.intern();将该对象AA的引用保存到常量池上
5.在堆上创建对象，在常量池上创建引用，不会再常量池中再创建常量
string a5=new string(“A”)+new string(“A”);在堆上创建对象
a5.intern（）；在常量池上创建引用
string a6=“AA”；此时不会再在常量池上创建常量AA，而是把a5的引用返给a6
sout(a5==a6);得到true