一.多态
1.多态的概念
(1) 多态：可以理解为事物存在的多种体现形态。
(2)多态的体现：
父类的引用指向了自己的子类对象。方法的重载。
方法的覆盖。
(3)多态的前提：
<1>必须是类与类之间有关系，要么继承，要么实现。
<2>通常还有一个前提：存在覆盖。(4)多态的好处：
多态的出现大提高了程序的扩展性。(5)多态的弊端：
只能使用父类的引用访问父类中的成员。2.转型（引用类型强制转换）
(1)类型提升--->向上转型 // Animal a = new Cat();
(2)转成子类型--->向下转型 // Cat c = (Cat)a;
3.多态中成员的特点
(1)多态中成员函数的特点：
<1>在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过。如果没有，编译失败。
<2>在运行时期：参阅对象所属的类中是否有调用的方法。
<3>总结：成员函数在多态调用时，编译看左边，运行看右边。
(2)多态中成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类).
(3)多态中，静态成员函数的特点：
无论编译和运行，都参考左边。
二.抽象类
1.概述
(1)当多个类中出现相同功能，但是功能主体不同，这时可以进进向上抽取。
(2)这时只抽取功能定义，而不抽取功能主体。
(3)抽象就是笼统的，不具体的，看不懂的。2.抽象类的特点：
(1)抽象方法一定在抽象类中。
(2)抽象方法和抽象类都必须被abstract关键字修饰。
(3)抽象类不可以用new创建对象，因为调用抽象方法没意义。
(4)抽象类中的抽象方法要被使用，必须由子类复写齐所有的抽象方法后，建立子类对象调用。
(5)如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
(6)抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
三.接口
1.接口:
初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以
通过接口的形式来表示。
2.区别：
class用于定义类。
interface用于定义接口。
3.接口的格式：interface{}
4.接口定义的格式特点：
(1)接口中常见定义：常量，抽象方法。
(2)接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
5.注意：
(1)接口中的成员都是public的。
(2)接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法
全部覆盖后，子类才可以实例化，否则子类是一个抽象类。
6.接口的特点：(1)接口可以被多实现，也可以多继承。
(2)接口是对外暴露的规则。
(3)接口是程序的功能扩展。
(4)接口降低了偶合性
(5)类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
(6)接口与接口之间可以有继承关系。
(7)基本功能定义在类中，扩展功能定义在接口中。
四.内部类
1.内部类
(1)将一个类定义在另一个类的里面，对里面那个类就称为内部类,或叫内置类，嵌套类。
(2)访问特点：
<1>内部类可以直接访问外部类中的成员，包括私有成员。
<2>外部类要访问内部类中的成员，必须要建立内部类的对象。3)注意：
<1>内部类之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用。
格式为：外部类名.this<2>内部类可以被私有封装。
<3>内部类可以被static修饰。
2.静态内部类
(1)访问格式：
<1>当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象。
格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象
如： Outer.Inner in = new Outer().new Inner();
<2>当内部类在成员位置上，就可以被成员修饰符所修饰。
比如：private:将内部类在外部类中进行封装。
static :内部类就具备static特性a.当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
b.在外部其他类中，如何直接访问static内部类的静态成员呢？
new Outer.Inner().function();
c.在外部其他静态类中，如何直接访问static 内部类的静态成员呢？
Outer.Inner.function();(2)注意：
<1>当内部类中定义了静态成员，该内部类必须是static的。
<2>当外部类中的静态方法访问内部类时，内部类也必须是静态的。3.内部类的定义原则：
当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容。4.匿名内部类：
要点：
(1)内部类只有定义在成员位置上时，才能被private和static所修饰，一般内部类是不会被public所修饰的。
(2)内部类可以被写在任意位置上，成员也可以。局部也可以。
(3)非静态，没对象不运行
(4)从内部类中访问局部变量，需要被声明为最终类型(加final).
(5)内部类定义在局部时：
<1>不可以被成员修饰符修饰。
<2>可以直接访问外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，
只能访问被final修饰的局部变量。注意：
(1)匿名内部类其实就是内部类的简写格式。
(2)定义匿名内部类的前提：内部类必须是继承一个类或者接口。
(3)匿名内部类的格式：new 父类或接口(){定义子类的内容}
(4)其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象。
(5)匿名内部类中定义的方法不要超过3个，最好是2个或者1个。
(6)定义匿名内部类，就是为了简化书写，覆盖方法。五.Object类
1.Object类
(1)Object:是所有对象的直接或者间接父类，是一个超类，该类中定义的肯定是所有对象都具备的功能。
(2)Object类中已经提供了对对象是否相同的比较方法，如果自定义类中也有比较相同的功能，没必要
重新定义，只要沿袭父类中的功能，建立自己特有的比较内容即可，这就是覆盖。
(3)java认为所有对象都具备比较性，该方法equals定义在Object中。
2.Object中方法：
(1)toString():返回该对象的字符串表示，所有对象都可以变成字符串打印。
(2)hashCode():返回该对象的哈希码值。
(3)getClass():返回此Object的运行时类。(4)wait();
(5)notify();
(6)notifyAll();
六.final关键字
final:意为“最终”，是一个修饰符。
(1)可以修饰类，函数，变量。
(2)被final修饰的类，不可以被继承。
(3)被final修饰的方法不可以被复写。如：final void show(){}//最终方法
(4)被final修饰的变量是一个常量。如：final int x=3;
(5)内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。七. 异常类
1 异常概述： 异常是对问题的描述，将问题封闭成对象 以便抛出和处理。
2 异常体系：
Throwable
|----------Error
|----------Exception
|----------RuntimeException
3 异常体系的特点：
异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。
4 throw 和Throws
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可抛出多个异常 用逗号隔开。5 当函数内有throw抛出异常对象，并未进行try处理 必须要在函数上声明，否则编译失败，
注意：RuntimeException及它的子类除外，也就是说，函数内如果抛出了RuntimeException异常，函数上可以不用声明，
如果函数声明了异常，调用者需要进行处理 处理方法可以throws也可以try.
6异常分为两种
(1)编译时被检测异常Exception，如果没有处理，那么编译失败，该异常可以被标识，代表可以被处理。
(2)运行时异常RuntimeException 不需要处理，该异常发生，让程序停止，需要对代码进行修正。
7，异常处理语句：
try{被检测的代码}catch{处理的代码}finally{一定会执行的语句}
finally通常是关闭资源，释放资源使用，只有当执行到System.exit(0)的时候 finally中的代码不会被执行。遇到return也要执行。
8自定义异常
(1)定义类继承Exception或RunTimeException
<1>为了让该自定义类具备可抛性。
<2>让该类具备操作异常的共性方法。(2)当要定义自定义异常的信息时，可以使用父类已经定义好的功能，将异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。10异常的好处：
(1)将问题进行封装。
(2)将正常流程代码和问题处理代码相分离，方便于阅读。11.异常处理原则：
(1)处理方式有两种：try或throws.
(2)调用到抛出异常的功能时，抛出几个就处理几个，一个try可对应多个catch.
(3)多个catch时，父类的catch放到最下面，否则子类的catch执行不到。
(4)catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace,输出语句，也不要不写。
(5)当捕捉到的异常，本功能处理不了时，可以继续在catch中抛出。12.异常的注意事项：
在子父类覆盖时：
(1)子类抛出的异常必须是父类的异常的子类或子集。
(2)如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try处理不能抛出。
八. 包1.包：
包也是一种封装形式，可对类文件进行分类管理，给类提供多层命名空间。
写在程序文件的第一行，类名的全称是：包名.类名2.包的好处：
包的出现可以让类文件和java的源文件相分离，可以很方便地只将类文件提供给别人使用。3 包与包之间的访问：
(1)一个包中的类要被访问，必须要有足够大的权限，所以被访问的类要被public修饰。
(2)类公有后，被访问的成员也要公有才可以被访问。
(3)包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
(4)不同包中的子类还可直接访问父类中被protected权限修饰的成员。
(5)包与包之间可以使用的权限只有两种：public,protected.
4.java中四种权限
public protected default private
同一个类中： OK OK OK OK
同一个包中： OK OK OK不同包子类： OK OK
不同包中： OK
5.import
(1)为了简化类名的书写，使用一个关键字import,import导入的是包中的类。
(2)import packb.*;为导入包中所有的类，尽量不要写通配符*，需要用到哪个类就导入哪个类，
都导进来比较占内存。
(3)建立定义包名不要重复，可以使用url来完成定义，因为url是唯一的。
如：package cn.itcast(4)包和子包中有重名类时，创建对象必须加包名。
如：packb包和子包haha中都有DemoC,创建packb包中DemoC对象代码为：
packb.DemoC c = new packb.DemoC();6.jar包
(1)java中的jar包是通过工具jar.exe完成的。
(2)java的压缩包方便项目的携带，方便于使用，只要在classpath设置jar路径即可。
(3)数据库驱动，SSH框架等都是以jar包体现的。九. String类
1.String概述:
(1)public final class String 此类不能有子类，也就是操作字符串的功能不可以被复写。
(2)String类代表字符串，java程序中所有的字符串字面值(如："abc")都作为此类的实例实现。
(3)字符串是常量，它们的值在创建后不能更改。
2.s1和s2的区别：
String s1="abc";
String s2=new String("abc");s1==s2 flase; ==比较的是两个对象的引用地址 这是两个不同的对象 所以false;
s1.equals(s2) true equals本身也是比较两个对象的引用地址
但是在这里被String字符串复写了，比较对象的内容是否相同。
s1在内存中有一个对象。
s2在内存中有两个对象。3.String 类在内存中的原理分析：
String类在内存中有一个常量池，也就是一个数组，将字符按指定顺序存入数组来组成字符串。4 String常见方法：
获取：
(1)获取长度：int length()
(2)根据位置获取字符：char charAt(int index)
(3)根据字符获取位置：
int indexOf(int ch):返回ch在字符串中第一次出现的位置。
int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(String str):返回str在字符串中第一次出现的位置。
int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(int ch):返回字符在字符串中最后一次出现的索引位置。判断：
(1)字符串中是否包含某一个子串：boolean contains(str)
(2)字符串中是否有内容：boolean isEmpty()
(3)字符串是否是以指定内容开头：boolean startsWith(str)
(4)字符串是否是以指定内容结尾：boolean endsWith(str)
(5)判断字符串内容是否相同(复写Object类中的equals方法):boolean equals(str)
(6)判断内容是否相同并忽略大小写：boolean equalsIgnoreCase()转换：
(1)将字符数组转成字符串：
构造函数：
String(char[])
String(char[],offset,count)//将字符数组中的一部分转成字符串。
静态方法：
static String copyValueOf(char[])
static String copyValueOf(char[] data,int offset,int count)
static String valueOf(char[])
(2)将字符串转成字符数组：char[] toCharArray()
(3)将字节数组转成字符串:
String(byte[])
String(byte[],offset,count)
(4)将字符串转成字节数组：byte[] getBytes()
(5)将基本数据类型转成字符串:
static String valueOf(int)
static String valueOf(double)
注:3+"" <==> String.valueOf(3);
字符串和字节数组在转换过程中，是可以指定编码表的。
替换和切割：
(1)String replace(oldChar,newChar);
(2)String replace(charSequence target,charSequence replacem):替换字符串
(3)切割：String[] split(regex)
(4)获取子串：
String substring(begin)
String substring(begin,end)
比较和去除空格：
(1)将字符串转成大写或小写：
String toUpperCase();
String toLowerCase();
(2)将字符串两端的多个空格去除：String trim();
(3)对两个字符串进行自然顺序的比较：int compareTo(String);十.StringBuffer
1.关于StringBuffer
(1)字符串的组成原理就是通过该类实现的。
(2)StringBuffer可以对字符串内容进行增删。
(3)StringBuffer是一个容器。
(4)很多方法与String相同。
(5)StringBuffer是可变长度的。2.public final class StringBuffer
StringBuffer不能被继承，它是字符串的缓冲区。
缓冲区特点：
长度可变。
可操作多个数据类型。
最终会通过toString方法变成字符串.才可以操作。3.StringBuffer中方法：
(1)存储：
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,data):可将数据插入到指定index位置。
(2)删除：
StringBuffer delete(start,end):删除缓冲区中的数据，包含start,不包含end.
StringBuffer deleteCharAt(index):删除指定位置的字符。
(3)获取：
char charAt(int index);
int indexOf(String str);
int lastIndexOf(String str);
int length();
String substring(int start,int end);
(4)修改：
StringBuffer replace(start,end,String str);
void setCharAt(int index,char ch);
(5)反转：
StringBuffer reverse();
(6)将缓冲区中指定数据存储到指定字符数组中：
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);
4StringBuilder和StringBuffer区别(1)StringBuffer是线程同步，多线程中使用。
StringBuilder是线程不同步，单线程使用。(2)StringBuilder:一般开发中用StringBuilder 比StringBuffer更高效。
十一. 基本数据类型包装类1.基本数据类型对象包装类:
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
2.基本数据类型对象包装类的最常见作用：
---就是用于基本数据类型和字符串类型之间做转换
(1)基本数据类型转成字符串：
基本数据类型 + "";
基本数据类型.toString(基本数据类型值);如：Integer.toString(34)
(2)字符串转成基本数据类型：
xxx a = XXX.parseXXX(String str);//静态方法
如：int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
3.十进制---->其他进制
toBinaryString();//2
toHexString();//16
toOctalString();//8
4.其他进制--->十进制
parseInt(string,radix);如：parseInt("110",10);
5.基本数据类型对象包装类新特性
Integer x=4;//自动装箱，隐式完成了new Integer(4)动作。
x=x+2;//x进行自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x;注：x的拆箱原理：x.intValue();
Integer x=null;//NullPointException空指针异常