一、关键字
this关键字
this关键字在方法内部使用，表示对“调用方法的那个对象”的引用，如果在方法内调用同一个类的另一个方法可以不使用this
super关键字
this && super
A:this本类的引用，super代表父类存储空间的标识（看成对父类的引用）
B:this.变量 ，super.变量 -----引用变量
this(.....) ，uper(.....) -----调用构造方法
this.成员方法 ，super.成员方法 -----调用成员方法
static关键字
static的特点：
1.类中static关键字修饰的变量（静态变量）被类的所有对象共享
class Static{ static int i=47; }
即使创建多个对象也共享同一个变量i：
Static st1=new Static(); Static st2=new Static();
st1.i和st2.i指向同一个存储空间地址，有相同的值，也可以通过Static.i引用变量
2.类中static修饰的方法可以在不创建方法的前提下直接调用
static修饰的方法不与包含它的类的任何对象关联在一起，不用创建对象通过类本身调用，这是static方法的主要用途
class Static{ public static void increment(){ Static.i++; } }
定义了一个静态方法，通过类直接调用：Static.increment()
3.静态是随着类的加载而加载,与对象无关
4.static方法没有this关键字
5.static方法不能调用非静态方法，反过来可以
6.所有构造方法都默认被static修饰
final关键字
1.修饰数据
声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量
final修饰基本类型（整型，浮点，字符等），表示一个常量，赋值后不可以改变
final修饰引用类型（类，接口，数组），final使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的
2.修饰方法
final修饰的方法不能被重写（private方法也不可重写）
private方法隐式地被指定为final，如果在子类中定义的方法和基类中的一个private方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法
3.修饰类
- final修饰的类不可以被继承
成员变量和局部变量
局部变量：在方法外---在栈内存 （变量没有默认初始值）---随之对象的创建产生，随着对象的消失
成员变量： 在方法内---在堆内存 （变量有默认初始值）--随着方法的调用产生
二、继承
java中继承的特点：
A: 只支持单继承，不支持多继承
B: 支持多层继承class A{} class B extends A{} class C extends B{}注意事项
A:子类只能继承父类中非私有的成员（成员变量和成员方法）
B:子类不能继承父类的构造方法，但可以通过super关键字去访问父类构造方法
1.访问权限
包访问权限（friendly） ：默认的访问权限通常是包访问权限，当前包中所有其他类可以访问那个成员，对于这个包之外的所有类是private
public：公共的，谁都可以访问
protected：继承访问权限
private：私有的，除了包含该成员的类之外其他类无法访问
！注意：
a.类不可以用private，protected修饰，只可以是包访问权限和public
b.如果类的构造方法由private修饰，则无法创建该类的对象，从而禁止拥有该类的访问权限，但是任然可以调用访问该类中static修饰的成员
2.类间的关系
组合
class Actor{ public void act() {} }
class HappyActor{ public void act(){ print("HappyActor"); }
class SadActor{ public void act(){ print("SadActor"); } }
class Stage{ privat Actor actor=new HappyActor(); public void change(){ actor=new SadActor(); } public void perform(){ actor.act(); } }
继承
代理
3.重写和重载
- 重写（Override）
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
为了满足里式替换原则，重写有有以下两个限制：
子类方法的访问权限必须大于等于父类方法；
子类方法的返回类型必须是父类方法返回类型或为其子类型。
使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
- 重载（Overload）
存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
应该注意的是，返回值不同，其它都相同不算是重载。
三、多态
1.多态的前提
要有继承关系，要有方法重写，要有父类引用指向子类对象（父类 F = new 子类())
class fu{
public fu(){
}
public void show(){
System.out.println("fu");
}
}
class zi extends fu{
public void show(){
System.out.println("show zi");
}
public void method(){
Sysltem.out.println("method zi");
}
}
class DuotaiDemo{
public static void main(String[] args){
fu f = new zi();
f.show();
}
}
2.多态中成员访问特点
A:成员变量—编译看左边，运行看左边
B:构造方法—创建子类对象时，访问父类的构造方法，对父类的数据进行初始化
C:成员方法—编译看左边，运行看右边（因为有成员方法重写，所以调用子类）
D:静态方法—编译看左边，运行看左边（静态只和类有关）
多态好处 ：提高了代码的维护性（继承）、扩展性（多态）
弊端 ：不能使用子类的特有功能
对象间的转型:
向下转型 父->子 zi z = (zi)f
向上转型 子->父 fu f = new zi()
四、接口
1.抽象类和抽象方法
抽象类和抽象方法必须用abstract修饰
格式：
abstract class 类名 {}
public abstract void 方法名();
特点：
- 抽样类中不一定有抽样方法，但是有抽样方法的类一定要定义成抽类
- 抽样类不能实例化，抽象类有构造方法，但不可以实例化，构造方法是给子类调用的
- 抽象类的子类：如果不想重写抽样方法，子类是一个抽样类，如果想重写抽样方法，子类是一个具体的类
成员特点：
- 成员变量：既可以是常量，也可以是变量
- 构造方法：有，用于子类访问父类数据初始化
- 成员方法：既可以是抽象的，也可以是非抽象的，成员方法是抽象的，子类必须得重写，成员方法是非抽象的，子类继承
2.接口
interface产生一个完全抽象的类，此类没有提供任何相应的具体实现，它允许确定方法名、参数列表、和返回类型，但是没有任何方法体。
- 接口只提供了形式，而未提供任何具体实现
- 接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected
- 接口的字段默认都是 static 和 final 的
A.接口成员特点：
成员变量：只能是常量，是静态的，默认修饰符 public static final
构造方法：没有（所有类都默认继承object类）
成员方法：只能是抽象方法，默认修饰符public
B.比较
从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
C.使用选择
使用接口：
a.需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
b.需要使用多重继承；
c.创建不带任何方法定义和成员变量的基类；使用抽象类：
a.需要在几个相关的类中共享代码；
b.需要能控制继承来的成员的访问权限，而不是都为 public；
c.需要继承非静态和非常量字段；
在很多情况下，接口优先于抽象类，因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低
D.关系
类和类：继承关系，只能单继承，多层继承
类和接口：实现关系，可以单实现也可以多实现，可以在继承一个类的同时实现多个接口
接口和接口：继承关系，可以单继承，也可多继承
五、内部类
匿名内部类
内部类的简写
前提：存在一个类和接口
类名或接口 格式： new名 () { 方法重写; };
本质是一个继承了该类或实现了接口的子类匿名对象
六、字符串
String主要方法
构造方法
public String() 空构造
public String(byte[] bytes)
把字节数组转换成字符串
public String(byte[] bytes,int offset,int length)
把字节数组一部分转换成字符串
public String(char[] value)
把字符数组转换成字符串
public String(char[] value,int offset,int count)
把字符数组一部分转换成字符串
public String(String original)
eg. String s = new String(参数)
成员方法
**判断功能**
public boolean equals(Object anObject) 比较字符串的内容是否相同
public boolean equalsIgnoreCase(String str) 比较字符串的内容是否相同，忽略大小写
public boolean contens(String str) 大的字符串是否包含小串
public boolean startsWith(String str) 判断字符串是否以某个特定的字符串开头
public boolean endsWith(String str) 判断字符串是否以某个特定的字符串结尾
public boolean isEmpty() 判断字符串是否为空
**获取功能**
public int length()
获取字符串长度
public char charAt(int index)
返回索引处的字符
public int indexOf(int ch)
返回指定字符第一次出现的字符串内的索引
public int indexOf(String str)
返回指定子字符串第一次出现的字符串内的索引。
public int indexOf(int ch,int fromIndex)
返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索
public int indexOf(String str,int fromIndex)
返回指定子串的第一次出现的字符串中的索引，从指定的索引开始
public String substring(int beginIndex)
返回一个字符串，该字符串是此字符串的子字符串。 子字符串以指定索引处的字符开头，并扩展到该字符串的末尾
public String substring(int beginIndex,int endIndex)
返回一个字符串，该字符串是此字符串的子字符串，子串开始于指定beginIndex并延伸到字符索引endIndex - 1
**转换功能**
public byte[] getBytes()
把字符串换换为字节数组
public toCharArray()
把字符串转换为字符数组
public static String valueof(char[] chs)
字符数组转化成字符串
public static String valueof(int i)
把int转化成字符串
public String toLowerCase()
字符串变小写
public String toUpperCase()
字符串变小写
public String concat(String str)
字符串拼接
**替换功能**
public String replace(char old,char new);
public String replace(String old,String new);
**去除字符串开头结尾两个空格**
public String trim();
**按字典顺序比较两个字符串**
public int compareTo(String str);
public int compareToIgnorceCase(String str);
String, StringBuffer and StringBuilder
- 可变性
String 不可变
StringBuffer 和 StringBuilder 可变 - 线程安全
String 不可变，因此是线程安全的
StringBuilder 不是线程安全的
StringBuffer 是线程安全的，内部使用 synchronized 进行同步
类型转换
String和StringBuffer相互转换
String s = new String()
A:StringBuffer sb = new StringBuffer(s)
B:StringBuffer sd2 = new StringBuffer()
sb2.append(s)
StringBuffer sb = new Stringbuffer("java")
A:String str = new String(sb)
B:String str2 = sb.toString()
String和int
int a=100;
String s2=String.valueOf(a);
System.out.println(s2);
String s ="100";
int y=Integer.parseInt(s);
System.out.println(y);
* 把int转化为String
1. String s=""+i;
2. String s=Integer.toString(i);
3. String s=String.valueOf(i);
* 把String转化为int型
1. int i=Integer.parsenInt(s);
2. int i=Integer.valueOf(s).intValue();
* 把String转化为Integer
* Integer integer=Integer.valueOf(i)
* 把Integer转化为int
* int num=Integer.intValue()；