NO8.java笔记【面向对象、抽象类、abstract、接口、interface、多态 、内部类、匿名内部类、异常、Object类】

/**
面向过程：1.打开冰箱 2.存储大象 3.关上冰箱。强调的过程（动作、功能、函数）。
面向对象：强调的是对象（实体）。冰箱【1.打开 2.存储 3.关闭】 调用
特点：1.面向对象就是一种常见的思想，符合人们的思考习惯。
2.面向对象的出现，将复杂的问题简单化。
3.让曾经在过程中的执行者，变成了对象中的指挥者(调用者)。
*/

一、面向对象：类和对象。

1.类是抽象的，概念的，代表一类事物。

2.对象是具体的，实际的，代表具体的事物。

3.类是对象的模板，对象是类的一个个体，实例。

成员变量是类的一个组成部分，一般是基本数据类型，也可以是引用类型（地址值）。

声明再创建：类名 对象名 ＝ new 类名（）；

对象－如何访问（使用）对象的成员变量：对象名.成员变量。

二、抽象类：

抽象：笼统，模糊，看不懂，不具体
特点：1.方法只有声明没有实现时，该方法就是抽象方法，需要被abstrace修饰。抽象方法必须定义在抽象类中，该类也必须被abstract修饰。

             2.抽象类不可以被实例化。因为调用抽象方法没意义（没方法体）。

             3.抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。

1.抽象类中有构造函数吗？

   有，用于给子类对象进行初始化。
2.抽象类可以不定义抽象方法吗？

   可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。

   通常这个类的方法有方法体，单是却没有内容。
3.抽象关键字不可以和哪些关键字共存？

   private 不行

   static  不行 类方法，只能类调用

   final   不行
4.抽象类和一般类的异同点？

   相同：抽象类和一般类都是用来描述事物的，都在内部定了成员。

   不同：1.一般类有足够的信息描述事物，抽象类描述事物的信息有可能不足。

               2.一般类不能定义抽象方法，只能定义非抽象方法。 抽象类可以定义抽象方法，同时也可以定义非抽象方法。
       3.一般类可以被实例化，抽象不可以被实例化。
5.抽象类一定是父类吗？

  是的，需要子类覆盖其方法后才可以对子类实例化。

abstract class Demo
{
abstract void show();
//{
//System.out.println("demo show");
//}
}
//DemoA和DemoB有共性，进行抽象成一个类。
class DemoA extends Demo
{
void show()
{
System.out.println("demoA show");
}
/*
void show()
{
System.out.println("demo show");
}
*/
}
class DemoB extends Demo
{
void show()
{
System.out.println("demoB show");
}
/*
void show()
{
System.out.println("demo show");
}
*/
}

class AbstractTest
{
public static void main(String[] args)
{
Demo a = new Demo();
}
}

三、接口

1、接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的方式来表示。

       class：用于定义类

       interface：用于定义接口
2、接口定义时，格式特点：

定义接口使用的关键字不是class，而是interface 。

对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1.全局常量：public static final   默认存在修饰符（不管修饰不修饰）。

2.抽象方法：public abstract

由此得出结论，接口中的成员都是公共的权限。

/接口不再用继承，而是用实现（全都重写）

//类与接口的实现关系。类与类之间是继承关系。

接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象类的方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。

接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。

接口可以被类多实现，一个类可以同时实现多个类。一个类在继承另一个类的同时，还可以实现多个接口。 

接口与接口之间是继承关系，而且接口可以实现多继承关系。

接口的出现避免了单继承的局限性。

在java 中不直接支持多继承，因为会出现调用的不确定性，所以在java将多继承机制进行改良，在java中变成了多实现。一个类可以实现多个接口。

类与类之间是继承关系

类与接口之间是实现关系

接口与接口之间是继承关系。

3、接口的特点：1.接口是对外暴露的规则。2.是程序的功能扩展。3.接口可以用来多实现

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5.接口与接口之间可以有继承关系。

4、抽象类和接口的异同点：

相同点：都是不断向上抽取而来的。

不同点：1.抽象类需要被继承，而且只能单继承 接口需要被实现，而且可以多实现

                2.抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用费抽象方法。接口只能定义抽象方法，必须由子类去实现。
                3.抽象类的继承，是is a关系，在定义该体系的基本共性内容。 接口的实现是like a 关系，在定义体系外额外功能。

四、多态：[b]本类事物即具备本类的形态，也具备了父类的形态[/b]

class Animal
{}
class Cal extends Animal
{}
class Dog extends Animal
{}
Cal c = new Cal();
Animal a = new Cal();

这就是对象的多态性。

简单说：就是一个对象对应着不同类型。

猫 x = new 猫()

动物 x = new 猫()

1.多态的体现:

  父类的引用指向了自己的子类对象

  Animal a = new Cat();

  父类的引用可以接收子类对象

2.多态的前提：必须是类与类之间的有关系，要么继承，要么实现。通常还有一个前提：存在覆盖

3.多态的好处：多态的出现大大扩大程序的扩展性。

4.多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类的成员。

多态的特点：

1、在多态中非静态成员函数的特点：（重写特性）

在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期，参阅对象所属类中是否有调用的方法。

简答总结就是：成员函数在多态调用时，编译看左边，运行时看右边。

2、在多态中成员变量的特点：

无论编译和运行，都参考左边（引用性变量所属的类）

3、在多态中，静态成员函数的特点：

无论编译和运行，都参考左边。

Animal a = new Cat();
//自动类型提升，猫对象提升为动物类型。访问出现局限性，但子类的特有功能无法访问
//作用：限制对特有功能的访问。
//专业讲：向上转型。
Cat c = (Cat)a;//向下转型，使得子类特有功能得到调用。

public static void method(Animal a)
{
if(a instanceof Cat)//instanceof：用于判断对象的具体类型，只能用于引用数据类型判断
{
//通常在向下转型前用于健壮性的判断
Cat c = (Cat)a;
c.eat();
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d = (Dog)a;
d.kanjia();
}
else
{
Pig p = (Pig)a;
p.gongdi();
}
}

五、内部类：将一个类定义在另一个类里面，对里面那个类就称为内部类（内置类，嵌套类）。

访问规则：

1.内部类可以直接访问外部类中的成员，包括私有的。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用：外部类名.this

2.外部类要访问内部类，必须建立内部类对象。
访问格式：

1.当内部类定义外部类的成员位置上，而且非私有，可以在外部类其他类中。可以直接建立内部类对象。

   格式：外部类名.内部类名 变量名=外部类对象.内部类对象。

                Outer.Inner in = new Outer().new Inner();

2.当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

            static:内部类就具备static的特性。

当内部类被static修饰后，只能访问外部类中static，出现局限性。

在外部其他类中，如何直接访问static内部类的非静态成员。
     new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类中的静态成员。
     Outer.Inner.function();

 注意：当内部类中的定义了静态成员，该内部类必须是static的。
     当外部类中的静态方法访问内部类时，内部类也必须是static.

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

*/
class Outer
{
int x = 3;
static class Inner  //内部类 静态
{
//int x = 4;
void function()
{
System.out.println("inner:"+Outer.x);
//int x = 6;
/*
System.out.println("inner :"+x);
System.out.println("inner :"+this.x);
System.out.println("inner :"+Outer.this.x);
*/
}
}
class Inner2
{
void show()
{
System.out.println("inner show");
}
}
void method()
{
Inner in = new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
//Outer out = new Outer();
//out.method();

//直接访问内部中的成员。
Outer.Inner in = new Outer().new Inner();
in.function();
}
}

/*
static是成员变量修饰符，不是局部变量修饰符。
内部类定义在局部时，
1.不可以被成员修饰符修饰
2.可以直接方位外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
*/
class Outer
{
int x = 123;
//void method()
void method(final int a)
{
final int y = 4;
//int y = 4;
/*
内部类定义在局部时，不可以被成员修饰符修饰，可以直接访问外部类中的成员，
因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，只能访问
final修饰的局部变量
*/
class Inner
{
//static void function()会报错
void function()
{
System.out.println(y);
System.out.println(Outer.this.x);
System.out.println(a);
}
}
new Inner().function();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
new Outer().method(777);
Outer out = new Outer();
//out.method(999);
//out.method(888);
}
}

/*
匿名内部类：
1.匿名内部类其实就是内部类的简写格式
2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
3.匿名内部类的格式：new父类或者接口(){定义子类的内容}
4.其实匿名内部类就是一个匿名子类对象。
5.匿名内部类中定义方法最好不要超过三个。
*/
abstract class AbsDemo
{
abstract void show();
//abstract void show1();
//abstract void show2();
//abstract void show3();
}

class Outer
{
int x = 5;
/*
class Inner extends AbsDemo    //内部类继承了一个外部其他类
{
//复写
void show()
{
System.out.println("show:"+x);
}
}
*/
public void function()
{
//Inner in = new Inner();
//in.show();
//in.abc();
//new Inner().show();
//new AbsDemo();闯将一个AbsDemo对象会出错，抽象类不可以创建一个对象。
//匿名内部类：方法只能被调用一次。
AbsDemo d = new AbsDemo()
//new AbsDemo()
{
void show()
{
System.out.println("x="+x);
}
void abc()
{
System.out.println("abc");
}
//}.show();//指的是调用其中的某个方法
};

d.show();
//d.abc();//编译失败;
/*
class Inner extends AbsDemo    //内部类继承了一个外部其他类
{
//复写
void show()
{
System.out.println("show:"+x);
}
}
*/
}
}
class InnerClassDemo5
{
public static void main(String[] args)
{
new Outer().function();
}
}