黑马程序员---Java基础学习笔记(面向对象篇)

------------Android培训、Java培训、期待与您交流----------

在面向对象的这个环节里，我就不罗列概念什么的了，着重讲两个我觉得应该重视的问题：内部类和多态。

1.内部类

定义：把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。

内部类访问规则：

1.内部类可以直接访问外部类中的成员，包括私有成员。
之所以可以直接访问外部类中的成员，因为内部类中持有一个外部类的引用。外部类.this
2.外部类要访问内部类，必须建立内部类对象。
3.当内部类在成员位置上，就可以被成员修饰符所修饰。
private：内部类在外部类中进行封装。
static： 内部类就具备static的特性。修饰后只能直接访问外部类中的static成员，出现了访问局限。
在外部其他类中，如何直接访问静态内部类中的非静态成员？new Outer.Inner().function();
在外部其他类中，如何直接访问静态内部类中的静态成员？Outer.Inner.function();
P.S.01当内部类定义了静态成员，该类必须是静态的。
P.S.02当外部类中的静态方法访问内部类时候，内部类也必须是静态的。

代码演示：

class Outer
{
	static class Inner01
	{
		void show()
		{
			System.out.println("inner01 show");
		}
	}
	public static void util()
	{
		new Inner01().show();
	}
	
	private static int x = 3;
	
	//Quiz03
	static class Inner
	{
		static int x = 5;
		static void function()
		{
			System.out.println("inner:"+x);
		}
	}
	/*Quiz02 
	static class Inner
	{
		int x = 5;
		void function()
		{
			System.out.println("inner:"+x);
		}
	}
	*/
	/*Quiz01
	class Inner
	{
		int x = 4;
		void function()
		{
			int x = 6;
			System.out.println("inner:" + x);//6
			System.out.println("inner:" + this.x);//4
			System.out.println("inner:" + Outer.this.x);//3
		}
	}
	*/
	/*Quiz00
	private class Inner//内部类可以定义为私有成员
	{
		void function()
		{
			System.out.println("inner:" + x);
		}
	}
	*/
	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}

public class InnerClass 
{
	public static void main(String[] args) 
	{
		Outer.util();
		//当private class Inner时
		//Outer out = new Outer();
		  //out.method();
		 
		
		 //直接访问内部类中的成员，必须无private前缀
		//Outer.Inner in = new Outer().new Inner();
		//in.function();
		
		//new Outer.Inner().function();Quiz02
		//Outer.Inner.function();//Quiz03
	}
}

2.匿名内部类

1.匿名内部类其实就是内部类的简写格式。
2.定义匿名内部类的前提：内部类必须是继承一个外部类或者实现接口。
3.格式：new 父类名称or接口(){定义子类的内容}
4.匿名内部类其实是一个匿名子类对象。且这个对象内容较多。
5.匿名内部类中定义的方法不要超过3个。保证内部类的简洁高效性。

代码演示：

abstract class AbsDemo
{
	abstract void show();
	abstract void run();
	//abstract void fuc();
}

class Outerss
{
	int x = 3;
	/*
	class Inner01 extends AbsDemo
	{
		void show()
		{
			System.out.println("show:"+x);
		}
	}
	*/
	public void function()
	{
		//new Inner01().show();
		//绿色部分的简化写法,整体是个对象，后边可以调用方法。
		new AbsDemo()
		{
			int x = 4;
			void show()
			{
				System.out.println("show:"+this.x);
			}
			void abc()
			{
				System.out.println("show sth...");
			}
			@Override
			void run() {
				// TODO Auto-generated method stub
				
			}
		}.show();//若想同时调用两个办法怎么办？
		
		AbsDemo d = new AbsDemo()
		{
			void show()
			{
				System.out.println("show:"+x);
			}
			void abc()
			{
				System.out.println("show sth...");
			}
			@Override
			void run() {
				// TODO Auto-generated method stub
				
			}
		};
		d.show();
		//d.abc();编译失败，因为子类依靠父类起的名字，子类只能使用父类中的方法。
	    //父类中没有定义此方法，子类无法调用。
	}
}

public class AnonymousIC 
{
	public static void main(String[] args) 
	{
		new Outerss().function();
	}
}

3.多态

定义：同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。水(气态，液态，固态)

多态前提

       A:存在着继承或者实现关系

       B:有方法的重写

       C:父类(接口)引用指向子类(实现)对象

多态的好处和弊端：

       好处：多态的存在提高了程序的扩展性和后期可维护性

       弊端：虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。不能预先使用子类中定义的特有功能。

多态中对象调用成员的特点

       Fu f = new Zi();

       A:成员变量：编译看左边，运行看左边

       B:成员方法：编译看左边，运行看右边

       C:静态方法：编译看左边，运行看左边

 多态的思想

       指挥同一批对象做事情。举例：带兵打仗，下课等。

多态中对象调用成员的特点代码演示：

class Father
{
	//Quiz02 int num = 5;
	public void method1()
	{
		System.out.println("F1");
	}
	public void method2()
	{
		System.out.println("F2");
	}
	//Quiz03
	static void method4()
	{
		System.out.println("F4");
	}
}

class Kids extends Father
{
	//Quiz02 int num = 8;
	public void method1()
	{
		System.out.println("K1");
	}
	public void method3()
	{
		System.out.println("K3");
	}
	//Quiz03
	static void method4()
	{
		System.out.println("K4");
	}
}

public class Polymorphic_2 
{
	public static void main(String[] args)
	{
		Kids k = new Kids();
		k.method1();//子类方法覆盖
		k.method2();//子类没有，调用父类方法
		k.method3();//子类特有
		
		//Quiz03 k.method4();
		
		//Quiz02 System.out.println(k.num);
		
		Father f = new Kids();//f此时是指向子类对象的
		f.method1();
		f.method2();
		
		//Quiz02 System.out.println(f.num);
		
		//Quiz03 f.method4();
	}
}
//Quiz 01
//多态中(非静态)成员函数的特点
//在编译期间，参阅引用变量（f）所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败。
//在运行期间，参阅对象（Kids）所属的类中是否有调用的方法。
//总结：成员函数在多态调用时，编译看引用变量，运行看对象。
//Quiz 02
//多态中成员变量的特点,静态成员变量也一样
//无论编译还是运行环节，都参考左边（引用变量所属的类）
//Quiz 03 静态成员函数
//无论编译还是运行环节，都参考左边

------------Android培训、Java培训、期待与您交流----------