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 关系，在定义体系外额外功能。

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

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();
	}
}