标签：类的变量 相同 style 类型 间接 不同 类成员 好处 ext
1.Java语言面向对象的三大关键特征
1）封装：将对象的数据和操作数据的方法相结合，通过方法将对象的数据与实现细节保护起来，称为封装。在java中，通过类
这种语言机制实现了数据的封装与隐藏。
2）继承：当两个类有继承关系时，子类可以重用父类中的代码，如果想修改，就重写，继承关系减少了程序中相类似代码的重复说明。
java中只支持类之间的单继承，多重继承要通过接口实现。
3.）多态：多态的含义可以表达为“对外一个接口，内部多种实现”。java语言支持两种形式的多态，运行时多态和编译时多态。
通过方法的重载实现编译时多态，而通过类之间的继承性，方法重写以及晚联编技术实现运行时多态。多态使程序具有
良好的可扩展性，并使程序易于编写维护和理解。
2.类的定义（一般步骤）
1）定义类名（这个必有，其他可有可无，如果全部都没有也可以，只不过这个类没什么实际意义）
2）添加成员变量
3）构造函数
4）方法
5）主函数（入口类才需要）
3.成员变量
①特征：
a.成员变量可以不赋值，因为其有初始化值。
b.成员变量作用于类中，即在类中都可以使用（不管是该类什么方法）。
②成员变量和局部变量的区别：
a.成员变量可以不赋值，但局部变量不可以
b.成员变量作用于类中，但是局部变量作用于某个方法或者语句中
c.成员变量在堆内存中存在，而局部变量在栈内存中（即如下面的after changeVar值一样
因为其为成员变量所以改变了之后就会一直保持改变后的值，不会因为程序结束而值恢复）
eg:类成员变量与局部变量同名是的操作示例
public class Vaetest{
private int x=1;
private int y=1;
private int z=1;
void changeVar(int a,int b,int c){
x=a;
int y=b; //y使同名类成员变量隐藏
int z=9; //z使同名类成员变量隐藏
System.out.private("In changeVar: "+"x="+x+"y="+y+y"z="+z);
this.z=c; //给类成员变量z赋值
}
String getXYZ(){
return "x="+x+"y="+y+"z="+z";
}
public static void main(String[] args){
Vaetest v=new Vartest();
System.out.println("before changevar:"+v.getXYZ());
v.changeVar(10,10,10);
System;out.println("after changeVar:"+c.getXYZ());
}
}
结果
before changevar:x=1 y=1 z=1
In changeVar;x=10 y=10 z=9
after changeVar x=10 y=1 z=10
4.构造函数
①特点：
1）函数名与类名相同
2）不用定义返回值类型
3）不可以写return语句
②作用：
给对象初始化（对象一建立就会调用与之对应的构造函数，当没有建立构造函数时，系统
会自动形成一个构造函数为 类名（）{}，以便初始化。重载多个构造函数是为了给不同
对象初始化。
注意：
1）默认构造函数的特点
2）多个构造函数是以重载的形式存在的
③构造函数与一般函数的差别
1）在写法上的不同
2）在运行上的不同
3）构造函数实在对象一建立就运行，给对象初始化，而一般方法是对象调用才执行，是给对象添加对象具备的功能
4）一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
④构造代码块（是定义不同对象共性的初始化内容）
1）作用：给对象初始化，对象一建立就运行，而且优先于构造函数执行
2）和构造函数的区别；
构造代码块是给所有对象进行统一初始化，而构造函数是给对应对象初始化。
简单的说
直接在类中定义的没有加static关键字的代码块{}称为构造代码块，例子程序如下：
public class CodeDemo02{
public CodeDemo02(){
System.out.println("========这是构造方法=========");
}
//这是构造代码块，而且在new对象时，构造代码块优先构造方法执行
{
System.out.println("=========这是构造块!=========");
}
public static void main(String[] args){
new CodeDemo02();
new CodeDemo02();
}
}
5.成员方法（函数）
①格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，....）
{
执行语句
return返回值
}
（小技巧：记住主函数的格式就可以了）
其中：
返回值类型：函数运行后的结果的数据类型（不确定用void，return语句省略）
参数类型：是形式参数的数据类型
形式参数：是一个变量，用于储存调用函数时传递给函数的实际参数。
实际参数；传递给形式参数的具体数值。
return语句：用于结束函数。
返回值：该值会返回给调用者
注意：参数类型不单单可以使基本数据类型，还可以是引用数据类型，即数组，类（字符串），接口。
②特点：
1）可以对功能代码进行封装；
2）便于被复用，提高了代码复用性；
3）函数只有被调用才会被执行；
4）void表示没有具体返回值，其return语句如果在最后一行可忽略不写（写的话直接“return；”即可）；
注意：
1）在函数内部可调用函数但不可定义函数
2）定义函数时，函数结果应该返回调用者，交由调用者去处理
③函数的重载
1）定义：在同一个类中，如果存在一个以上的同名函数时，就叫重载；
2）使用方法：只要参数个数或者类型不同；
3）特点：与返回值类型无关，只看参数列表；
4）优点：方便于阅读，优化了程序设计；
扩展：构造函数的重载
1）使用方法：也是只看参数个数或者类型不同（简单就是只看参数列表）
2）注意：其执行与代码的次序无关，不管是函数的重载还是构造函数的重载
④方法调用中的参数传递方法
1）基本数据类型
函数为add(int n);调用时add（3）;等价于int n=3；
2）对象
函数为add(Object s);调用时add("321");等价于Object s="321";
6.this
其作用有四种，分别如下：
①在构造方法中，引用该类中另一个构造方法
1）格式this（）;括号里面的为变量，与构造函数的变量相对应；
2）this函数只能定义在构造函数第一行and不可两者相互调用；
3）不能在构造函数以外的任何函数内调用构造函数；
4）在一个构造函数内只能调用一个构造函数；
②当成员变量与局部变量相同时，用于区分两者不同，成员变量前加this关键字
③this是代表本类对象的参数
④当内部类的变量和方法与外部类相同时，为了引用外部类的变量或方法，格式为：
外部类名.ths.方法名（属性名）
7.访问控制
8.Java可变参数
①定义：在类型确定，但参数个数不确定时，Java把可变参数当做数组进行处理。
②特点：
a.只能出现在参数列表的最后;
b.“...”位于变量类型和变量名之间，前后有无空格都是可以的;
c.调用可变参数的方法时，编译器会为认可变参数隐含创建一个数组，在方法体中是以数组的形式访问可变参数.
③注意：可变参数必须位于最后一项且在方法中只有能一个可变参数
④例子：
public class Varable {
public static void main(String [] args){
System.out.println(add(2,3));
System.out.println(add(2,3,5));
}
public static int add(int x,int ...args){
int sum=x;
for(int i=0;i<args.length;i++){
sum+=args[i];
}
return sum;
}
}
9.内部类
①定义：内部类是指在一个外部类的内部再定义类，那么该类为内部类。
②与外部类的区别：
内部类：可为静态，也可用protected，private修饰
外部类：只能使用public和缺省的报访问权限（default）
③内部类的种类
1）成员内部类
2）局部内部类
3）静态内部类
4）匿名内部类
④为什么需要内部类？
每个内部类都能独立地继承自类或接口的实现，不管外部类是否已经继承某个累或实现某个接口，同时，内部类的代码操作可创建访问外部类对象，即独立又有联系。
⑤类型解析
A：成员内部类（即就是在类里面在单独有一个类（如同成员），与外部类的属性、方法并列。)
public class Outer {
private static int i = 1;
private int j = 10;
private int k = 20;
public static void outer_f1() {
}
public void outer_f2() {
}
// 成员内部类中，不能定义静态成员
// 成员内部类中，可以访问外部类的所有成员
class Inner {
// static int inner_i = 100; //内部类中不允许定义静态变量
int j = 100; // 内部类和外部类的实例变量可以共存
int inner_i = 1;
void inner_f1() {
System.out.println(i);
//在内部类中访问内部类自己的变量直接用变量名
System.out.println(j);
//在内部类中访问内部类自己的变量也可以用this.变量名
System.out.println(this.j);
//在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
System.out.println(Outer.this.j);
//如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
System.out.println(k);
outer_f1();
outer_f2();
}
}
//外部类的非静态方法访问成员内部类
public void outer_f3() {
Inner inner = new Inner();
inner.inner_f1();
}
// 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
public static void outer_f4() {
//step1 建立外部类对象
Outer out = new Outer();
//step2 根据外部类对象建立内部类对象
Inner inner = out.new Inner();
//step3 访问内部类的方法
inner.inner_f1();
}
public static void main(String[] args) {
//outer_f4(); //该语句的输出结果和下面三条语句的输出结果一样
//如果要直接创建内部类的对象，不能想当然地认为只需加上外围类Outer的名字，
//就可以按照通常的样子生成内部类的对象，而是必须使用此外围类的一个对象来
//创建其内部类的一个对象：
//Outer.Inner outin = out.new Inner()
//因此，除非你已经有了外围类的一个对象，否则不可能生成内部类的对象。因为此
//内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类，
//那就不需要对其外围类对象的引用。
Outer out = new Outer();
Outer.Inner outin = out.new Inner();
outin.inner_f1();
}
}
总结：
1）该内部类的定义就是在类里面再定义一个类；
2）使用原则：
i.成员内部类中，不能定义静态成员，其它跟普通类一样；
ii.内部类访问外部类：访问变量(方法）：无同名，可直接访问，有同名，外部类名.this.变量（方法）名；
iii.外部类访问内部类：
①静态方法访问非静态变量（方法）
（1）内部类为静态内部类：Outer.Inner a=new Outer.Inner();
a.inner_f1();
（2）内部类为非静态内部类：Outer out=new Outer();
Outer.Inner a=out.new Inner();
a.inner_f1();
②非静态方法访问非静态变量（方法）
Inner a=new Inner();
a.inner_f1();
3）内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。
B:局部内部类（在“方法”中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。）
public class Outer {
private int s = 100;
private int out_i = 1;
public void f(final int k) {
final int s = 200;
int i = 1;
final int j = 10;
//定义在方法内部
class Inner {
int s = 300; // 可以定义与外部类同名的变量
// static int m = 20; //不可以定义静态变量
Inner(int k) {
inner_f(k);
}
int inner_i = 100;
void inner_f(int k) {
//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
System.out.println(out_i);
//可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
System.out.println(j);
//System.out.println(i);
//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
System.out.println(s);
//用this.变量名访问的也是内部类变量
System.out.println(this.s);
//用外部类名.this.内部类变量名访问的是外部类变量
System.out.println(Outer.this.s);
}
}
new Inner(k);
}
public static void main(String[] args) {
// 访问局部内部类必须先有外部类对象
Outer out = new Outer();
out.f(3);
}
}
总结：
1）定义：在方法体内定义一个类，该类与局部变量类似。
2）使用原则：
i.不能有说明符
ii.可以访问当前代码块内的局部变量，但其必须是final的（即常量）
iii.访问外部类的变量（方法）：
如果内部类和外部类的成员变量（方法）有同名
（1）直接使用变量（方法），访问内部类的变量（方法）；
（2）用this.变量（方法），访问内部类的变量（方法）；
（3）外部类名.this.变量（方法），访问外部类变量（方法）；
如果不同名：直接使用变量（方法），就可直接访问外部类变量（方法）；
iiii.如何得到内部类：访问局部内部类必须先有外部类对象之后，调用方法去使用内部类的方法（直接使用构造函数，间接使用内部类方法）
C：静态内部类(嵌套类)：（注意：前两种内部类与变量类似，所以可以对照参考变量）
说明：如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。
想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。
然而，当内部类是static的时，就不是这样了。嵌套类意味着：
1） 要创建嵌套类的对象，并不需要其外围类的对象。
2）.不能从嵌套类的对象中访问非静态的外围类对象。
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1() {
}
public void outer_f2() {
}
// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
static class Inner {
static int inner_i = 100;
int inner_j = 200;
static void inner_f1() {
//静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
System.out.println("Outer.i" + i);
outer_f1();
}
voidinner_f2() {
// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
// System.out.println("Outer.i"+j);
// outer_f2();
}
}
public void outer_f3() {
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}
publicstaticvoid main(String[] args) {
newOuter().outer_f3();
}
}
总结：
1）前提：不需要内部类对象与其外部类对象之间有联系，可以将内部类声明为static，其也称为嵌套类。
2）好处和坏处：
好处：要创建嵌套类的对象，并不需要起外围类的对象
坏处：不能从嵌套类的对象中访问非静态的外部类成员
3）使用规则：
（1）静态内部类可以用public，protected，private修饰
（2）静态内部类中可以定义静态或非静态的成员
（3）静态内部类中只能访问外部类的静态成员，不能访问非静态成员
（4）外部类访问内部类的静态成员：直接内部类名.静态成员即可使用；
外部类访问内部类的非静态成员：实例化内部类再使用即可；
4）如何得到内部类：
可直接生成，不需要外部类对象：Outer.Inner in=new Outer.Inner();
D：匿名内部类(匿名内部类就是没有名字的内部类)
1）前提：必须继承一个父类或实现一个接口，且要实现所有抽象方法，因为要实例化。
2）定义：匿名内部类也就是没有名字的内部类，只能使用一次。
3）使用原则：
（1）匿名内部类不能有构造方法
（2）匿名内部类不能定义任何静态成员，方法和类
（3）匿名内部类不能是public，protected，private，static
（4）只能创建匿名内部类的一个实例
（5）一个匿名内部类一定是在new的后面，用其隐含实现一个接口或继承一个类
（6）因匿名内部类为局部内部类，所以局部内部类的所有限制对其都生效
4）实例：
（1）匿名内部类的基本实现
抽象类：
abstract class person{
public abstract void eat();
}
实现类：
public class Demo{
public static void main(String[] args){
Person p=new Person(){
public void eat(){
System.out.println("eat something");
}
};
p.eat();
}
}
（2）在接口上使用匿名内部类
接口：
interface Person{
public void eat();
}
实现类：
public class Demo{
public static void main(String[] args){
Person p=new Person(){
public void eat(){
System.out.println("eat something");
}
};
p.eat();
}
}
（3）Thread类的匿名内部类实现
public class Demo{
public static void main(String[] args){
Thread t=new Thread(){
public void run(){
System.out.println("1");
}
};
t.start();
}
（4）Thread类的Runnable接口
public class Demo{
public static void main(String[] args){
Runnable r=new Runnable(){
public void run(){
System.out.println("1");
}
};
Thread a=new Thread(r);
a.start();
}
}
⑥.内部类的重载问题
如果你创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被重载吗？这看起来似乎是个很有用的点子，但是“重载”内部类就好像它是外围类的一个方法，其实并不起什么作用：
class Egg {
private Yolk y;
protected class Yolk {
public Yolk() {
System.out.println("Egg.Yolk()");
}
}
public Egg() {
System.out.println("New Egg()");
y = new Yolk();
}
}
publicclass BigEgg extends Egg {
publicclass Yolk {
public Yolk() {
System.out.println("BigEgg.Yolk()");
}
}
publicstaticvoid main(String[] args) {
new BigEgg();
}
}
输出结果为：
New Egg()
Egg.Yolk()
缺省的构造器是编译器自动生成的，这里是调用基类的缺省构造器。你可能认为既然创建了BigEgg 的对象，那么所使用的应该是被“重载”过的Yolk，但你可以从输出中看到实际情况并不是这样的。
这个例子说明，当你继承了某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的两个实体，各自在自己的命名空间内。当然，明确地继承某个内部类也是可以的：
class Egg2 {
protected class Yolk {
public Yolk() {
System.out.println("Egg2.Yolk()");
}
public void f() {
System.out.println("Egg2.Yolk.f()");
}
}
private Yolk y = new Yolk();
public Egg2() {
System.out.println("New Egg2()");
}
public void insertYolk(Yolk yy) {
y = yy;
}
public void g() {
y.f();
}
}
public class BigEgg2 extends Egg2 {
public class Yolk extends Egg2.Yolk {
public Yolk() {
System.out.println("BigEgg2.Yolk()");
}
public void f() {
System.out.println("BigEgg2.Yolk.f()");
}
}
public BigEgg2() {
insertYolk(new Yolk());
}
public static void main(String[] args) {
Egg2 e2 = new BigEgg2();
e2.g();
}
}
输出结果为：
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()
总结：现在BigEgg2.Yolk 通过extends Egg2.Yolk 明确地继承了此内部类，并且重载了其中的方法。Egg2 的insertYolk()方法使得BigEgg2 将它自己的Yolk 对象向上转型，
然后传递给引用y。所以当g()调用y.f()时，重载后的新版的f()被执行。第二次调用Egg2.Yolk()是BigEgg2.Yolk 的构造器调用了其基类的构造器。可以看到在调用g()的时候，新版的f()被调用了。
⑦.内部类的继承问题（thinking in java 3th p294）
因为内部类的构造器要用到其外围类对象的引用，所以在你继承一个内部类的时候，事情变得有点复杂。问题在于，那个“秘密的”外围类对象的引用必须被初始化，
而在被继承的类中并不存在要联接的缺省对象。要解决这个问题，需使用专门的语法来明确说清它们之间的关联：
class WithInner {
class Inner {
Inner(){
System.out.println("this is a constructor in WithInner.Inner");
};
}
}
public class InheritInner extends WithInner.Inner {
// ! InheritInner() {} // Won‘t compile
InheritInner(WithInner wi) {
wi.super();
System.out.println("this is a constructor in InheritInner");
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}
输出结果为：
this is a constructor in WithInner.Inner
this is a constructor in InheritInner
可以看到，InheritInner 只继承自内部类，而不是外围类。但是当要生成一个构造器时，缺省的构造器并不算好，而且你不能只是传递一个指向外围类对象的引用。
此外，你必须在构造器内使用如下语法：
enclosingClassReference.super();
这样才提供了必要的引用，然后程序才能编译通过。
⑧.内部类特性总结：
（1）内部类的类名只用于定义它的类或语句块之内，在外部引用它时必须给出带有外包类名的完整名称，并且内部类的名字不许与外包类的名字相同；
（2）内部类可以访问外包类的静态或实例成员变量；
（3）内部类可以在成员方法中定义，该成员方法的局部变量及参数必须是final才能被该内部使用；
（4）内部类可以是抽象类或接口。如果是接口，则可以由其他内部类实现；
（5）内部类可以使用public，protected，default或private等四种访问权限控制；
（6）内部类可以被声明为static（普通类不可以），这样的内部类变成顶层类，相当于把它放在外面，不再是嵌套的内部类，并且它的对象中将不包含指向外部类对象的指针，所以不能再引用外部类对象；
（7）只有顶层类可以声明static成员。如果内部类需要声明static成员，则该内部类必须声明为static；
10.对象的声明周期
1）.生命周期为对象的创建，对象初始化，对象的使用，对象的清除。
2）对象创建有两个步骤：
a.声明对象变量（給该变量分配一个引用空间）
b.对象的实例化（为对象分配空间，执行new运算符后的构造方法完成对象的初始化，并返回该对象的引用）
3）.初始化过程
a.首先为对象分配内存空间，并将成员变量进行初始化。（数值型变量初值为0，逻辑型为false，引用型为null）
b.然后执行显示初始化，即执行在类成员声明时带有的简单赋值表达式。
c.执行构造方法，进行对象的初始化。
4）对象的使用
a.引用对象的变量
A a=new A（）；
a.b=1;
b.引用对象的方法
A a=new A();
a.set();
5）对象的清除
a.java对象清除机制：java运行系统会在确定某个对象不再被使用时（即不存在任何引用的对象）自动将其删除。这个过程叫做垃圾收集。
b.把某个对象的引用删除
Point origin=new Point(21,45);
origin=null; //进行删除操作
c.垃圾收集器。
（1）原理：java运行系统中的垃圾收集器周期性的释放不再被引用的对象所占有的内存，自动执行内存回收。
（注意：垃圾收集器是以低优先级在系统空闲周期中执行，因此垃圾的收集速度比较慢。所以如果我们有需求说想马上
进行回收的话，我们可以显性执行垃圾收集（System.gc()) )
（2）对象的最终化处理
原理：如果一个对象要被收集了，在之前，垃圾收集器将调用该对象的finalize()方法，以使对象自己能够做最后处理，释放占有的资源，
这个过程叫做对象的最终化。
注意：这个方法存在object对象中，所以本身就会执行，如果我们想要实现特定的最终化处理,需要在代码块中执行super.finalize()，
之后在代码块中像怎么写就怎么写，但是释放资源的只能利用系统的方法。
例如：
protected void finalize() throws throwable{
super.finalize();
//其他代码
}
11.类的继承
1）为什么要有继承？
（1）提高代码的复用性
（2）让类与类之间产生了关系，有了这种关系，才有了多态的特性
注意：千万不要为了获取其他类的功能或简化代码而继承，必须是类与类之间有所属关系才可以
2）如何利用
格式 class 子类名 extends 父类名
3）何时使用
当发现多个类中有共性，将这些共性创建一个父类，从而在这多个类中写格式以获得共性，减少代码的书写
4）java语言中，java只支持单继承，不支持多继承，因为多继承容易带来安全隐患，当多个父类中定义了相同功能，但功能内容不同是，子类对象不确定运行那个
5）结果
继承后获得父类的各项属性和功能
6）如何使用一个继承体系中的功能呢？
（1）想要使用体系，必须查阅体系中父类的描述，因为父类中定义的是该体系中共性功能
（2）通过了解共性功能，就可以知道该体系的基本功能那么这个体系已经可以基本使用了，那么在具体调用时，要创建最子类对象，为什么呢？
一.是因为有可能父类不能创建对象（抽象甚至接口）
二.是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
7）重写（覆盖）
（1）为什么需要重写？
当子类继承父类，沿袭了父类的功能，但子类中需要的功能与父类不同，于是需要修改，重写。
（2）重写的要求
a.名字和参数类型一样
b.子类中重写方法的返回值类型必须与父类中被重写的方法的返回值类型相同
c.子类中重写方法的访问权限不能缩小
d.静态只能覆盖静态
e.子类中重写方法不能抛出新的异常
12.super关键字
1）功能：任何类都具有本类对象this引用，如果有继承，那么其还有个super引用值。其都在堆内存当中，进而引用我们的本类和父类对象。
2）内存体现：子类是把父类包裹起来的，而某个类又把自己的成员变量，函数包裹起来，所以即使是同名的，两者也是不会影响的，其都在堆内存中。
而super和this引用空间也在堆内存当中进而引用父类和子类的成员。
13.多态
1）多态的体现
父类的引用指向了自己的子类对象，父类的引用也可以接收自己的子类对象
2）多态的前提
必须是类与类之间有关系，要么继承，要么实现，本质就是“要覆盖”。
3）多态的好处（意义）
多态的出现大大提高了程序的扩展性
4）多态的弊端
虽然提高了扩展性，但是只能使用父类的引用访问父类的成员（方法），但使用子类覆盖的方法
5）多态的出现代码中的特点（多态使用的注意事项）
在编译时期：参阅引用型变量所述的类中是否有该方法。如果有，编译通过，如果没有，编译失败。
在运行时期：参阅对象所属的类中是否有调用方法。
6）多态的两种类型
编译时多态：主要是方法的重载，通过参数列表的不同来区分不同的方法。
运行时多态：也叫作动态绑定，一般是指在执行期间（非编译期间）判断引用对象的实际类型，根据实际类型判断并调用相应的属性和方法。主要用于继承父类和实现接口时，父类引用指向子类对象。
14.对象类型的强制转换
1）instanceof
功能:测试两个类是否有字符类关系，是，返回true，否则，false。
格式: 类名1 instanceof 类名2
2）强制转换
格式： （子类类型）父类类型
规则：
（1）必须得是父子关系才能强转
（2）在运行时也会检查（不是子父类关系会抛出异常）
15.Object类
1）概述
java.lang包在使用的时候无需显示导入，编译时由编译器自动导入。
Object类是类层次结构的根，Java中所有的类从根本上都继承自这个类。
Object类是Java中唯一没有父类的类。
其他所有的类，包括标准容器类，比如数组，都继承了Object类中的方法。
2）特殊性质
object子类可以重写如下：
clone()
equals()/hashCode()(这两个方法必须同时重写），
finalize()
toString()
不能重写的方法如下：
notify()
notifyAll()
wait()
3.常用方法说明
a. clone()方法
功能：将一个已有对象复制为另一个对象。格式为 对象.clone()
（上述格式将创建一个与对象相同类型的对象，并把该对象成员变量的值初始化为对象中相应成员变量的值。）
注意问题：
1.调用了clone方法的对象必须实现java.lang.Cloneable接口，否则运行时将抛出CloneNotSupportedException异常。
（因为object没有实现这个接口，所以使用这个方法的对象必须实现这个接口）
2.clone()方法是浅复制，不是深复制。
（所谓的浅复制就是如果成员变量是引用型变量，那么其只会复制其引用型对象，不会复制实在的数据对象。）
实例：
b.equals()方法
功能：
1.如果是public boolean equals(object obj)方法，其比较当前对象的引用是否与参数obj指向同一个对象，如果是，返回true。
2.如果是String,Data,File类和所有包装类的话都重写了1方法，改为比较所指对象的内容。
注意：java中的“==”对于引用型变量，其比较的是两个变量所值对象的地址，所以要比较字符串是否相同，应该用equals方法。
c.toString()
功能：返回对象的字符串表示,表达的内容因对象而异。（一般情况下会重写）
例子：System.out.println(Thread.currentThread().toString());//可以显示当前线程的信息
注意：调用Integer对象的toString()方法，将得到该对象所包含的整型数的字符表示。
d.getClass()方法
功能：返回一个Class类型的对象。
实例：
1.获取对象类名并且显示
void getClassName(Object obj){
System.out.println("The class of the object is"+obj.getClass().getName());
2.获取与obj相同类型的对象
Object createNewInstanceOf(Object obj){
return obj.getClass().newInstance();
}
在已知类名的情况下，还有其他两种获取类的方法。假设类名String
1.String.class
2.Class.forName("String")
标签：类的变量 相同 style 类型 间接 不同 类成员 好处 ext
原文地址：http://www.cnblogs.com/lpd1/p/7161750.html
