黑马程序员_java面向对象2

---------------------- ASP.Net+Android+IOS开发 、 .Net培训 、期待与您交流！ ----------------------

一、     继承的概述

1.1、继承（extends）优点：

1). 提高代码的复用性；

2).父类的方法和属性可以用于子类；

3). 让类与类之间产生了关系，有了这个关系，才有了多态的特性。

 

注意：千万不要为了获取其他类的功能，简化代码而继承；必须是类与类之间有所属关系才可以继承。所属关系 is a。

 

二、     继承的特点

java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患：当多个父类中定义了相同功能，功能内容不同时，子类对象不确定运行哪一个。 但java保留了这种机制，并用另一种体现形式来完成表示，即多实现。

java支持多层继承，也就是一个集成体系

 

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，也就可以知道该体系的基本功能，那么这个体系也就基本可以使用了。那么在具体调用时，要创建最子类的对象，为什么呢？

一是因为有可能父类不能创建对象；

二是创建子对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

 

三、     super关键字

子父类出现后，类成员的特点：

类中成员：

1、变量；

2、 函数；

3、 构造函数

 

1). 变量如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量用this，子类要访问父类中的同名变量用super。

super的使用和this的使用几乎一致，

this代表的是本类对象的引用，

super代表的是父类对象的引用。

 

四、     函数覆盖

2).子父类中的函数：

当子类出现和父类一模一样的函数式，当子类对象调用该函数，会运行子类函数的内容，如同父类函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）。

当子类继承父类，沿袭了父类的功能到子类中，但虽然子类具备该功能，但功能中的内容与父类的不一致。这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

覆盖注意事项：

A、 子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

B、 静态只能覆盖静态。

C、 重载：只看同名函数的参数列表；

    重写：父子类方法要一模一样。

 

3).子父类中的构造函数：

在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super()；

super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类中的构造函数？

因为父类中的数据子类可以直接获取，所以子类对象在建立对象时 ，需要先查看父类是如何对这些数据进行初始化。所以子类在对象初始化时，要先访问以下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来制定。

注意：super语句一定要定义在子类构造函数的第一行。

 

五、     子类的实例化过程

子类的实例化过程：

结论：子类中的所有构造函数默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

 

六、     final关键字

final:最终，作为一个修饰符。

1. 可以修饰类，函数，变量；

2. 被final修饰的类不可以被继承。为了避免被继承，被子类复写功能；

3. 被final修饰的方法不可以被复写；

4. 被final修饰的变量时一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量；

 

当描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性

都给这些值起个名字方便阅读，而这个值不需要改变，所以加上final修饰，作为常量：常量的书写规范有字母都大写，如果由多个单词组成，单词间通过_连接。

5. 内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

 

七、     抽象类

当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取，这时只抽取功能定义，而不抽取功能主体。

抽象(abstract)：看不懂。

抽象的特点：

1. 抽象方法一定在抽象类中；

2. 抽象方法和抽象类都必须被abstract关键字修饰；

3. 抽象类不可以用new创建对象，因为调用抽象方法没有意义；

4. 抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

示例：

abstract class Student  //定义一个抽象类；
{
	abstract void study(); //定义抽象方法；
	void sleep()
	{
		System.out.println("睡觉");
	}
}

class BaseStudent extends Student  //BaseStudent继承抽象类；
{
	public void study()  //覆盖父类中的抽象方法；
	{
		System.out.println("base study!");
	}
}

class AdvStudent extends Student
{
	public void study()
	{
		System.out.println("Adv study!");
	}
}

class AbstractDemo 
{
	public static void main(String[] args) 
	{
		BaseStudent bs = new BaseStudent();
		bs.sleep();
	}
}

 

抽象类和一般类没有太大不同。该如何描述事物，就如何描述事物，只不过该事物中出现了一些看不懂的东西，这些不确定的部分也是该事物的功能，需要明确出现，但是无法定义主体。通过抽象方法来表示。

抽象类比一般类多了个抽象函数，就是在在类中可以定义抽象方法。抽象类不可实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

 

八、     接口

8.1、接口的表现形式及与类的关系

格式：interface{}

 

接口的出现将“多继承”通过另一种形式体现出来，即多实现。

接口：初期理解：可以认为是一个特殊的抽象类

当抽象类的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类；

interface 用于定义接口。

       接口定义时格式特点：

1. 接口中常见定义：常量，抽象方法；

2. 接口中的成员都有固定修饰符。

   常量：public static final

   方法：public abstract

记住：接口中的成员都是public的。

示例：

interface Inter

{

       public static final int NUM = 3;

       public abstract void show();

}

 

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

接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现。

 

       8.2、接口的特点

       接口是对外暴露的规则；

       接口是程序功能的扩展；

       接口可以用来多实现；

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

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

 

九、     多态

9.1、多态：可以理解为事物存在的多种体现形态。

1). 多态的体现：

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

   父类的引用也可以接受自己的子类对象。

2). 多态的前提：

   必须是类与类之间有关系，要么继承，要么实现。

   通常还有一个前提：存在覆盖。

3). 多态的好处

   多态的出现大大的提高了程序的扩展性。

4). 多态的弊端：

   提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5). 多态的应用

6). 多态的出现代码中的特点（多态使用的注意事项）

 

Animal a = new Cat();//类型提升：向上转型（子类提升为父类类型);

a.eat();

 

如果想要调用猫的特有方法时：强制将父类的引用转成子类类型。向下转型。

Cat c = (Cat)a;

c.catchMouse;

多态自始至终都是子类对象在做变化。

 

9.2、

9.2.1、在多态中成员函数的特点：

在编译时期(父类引用指向子类对象)：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败。

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

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

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

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

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

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

class Fu
{
	int num = 5;
	void method1()
	{
		System.out.println("fu_method1");
	}
	void method2()
	{
		System.out.println("fu_method2");
	}
	static void method4()
	{
		System.out.println("fu_method4");
	}
	
}

class Zi extends Fu
{
	int num = 8;
	void method1()
	{
		System.out.println("zi_method1");
	}
	void method3()
	{
		System.out.println("zi_method3");
	}
	static void method4()
	{
		System.out.println("fu_method4");
	}
}


class DuoTaiDemo1 
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();
		Zi z = new Zi();
		f.method1();
		f.method2();
		//f.method3();  //编译失败；
		f.method4();    //method4为静态，所以输入为左边父类中的方法；
		System.out.println(f.num);
		System.out.println(z.num);
	}
}

      运行结果：zi_method1

          fu_method2

            fu_method4

          5

8

 

十、     内部类

10.1、内部类概念

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

10.2、内部类的访问规则：

1. 内部类可以直接访问外部类的的成员，包括私有；

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

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

 

10.3、访问格式：

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

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

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

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

private：将内部类在外部类中进行封装；

static： 内部类就具备了static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中(main函数中)，如何访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？

Outer.Inner.function();

 

注意：当内部类中定义了静态成员，该内部类必须是static的。

      当外部类中的静态方法访问内部类时，内部类也必须是static的。

 

10.4、如何使用内部类

    当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。（最好将内部类封装在外部类中，对外提供方法来访问）

 

10.5、匿名内部类

10.5.1、内部类定义在局部时：

1. 不可以直接被成员修饰符修饰；

2. 可以直接访问外部类中的成员，因为还持有外部类中的引用。

   但是不可以访问它所在的局部变量，只能访问被final修饰的局部变量。

class Outer
{
	private int x = 3;

	public void method()
	{
		final int y = 4;
		class Inner
		{
			void function()
			{
				System.out.println(x);
				System.out.println(y);  //局部变量只有被final修饰时，才可以访问(Inner在局部)
			}
		}
		new Inner().function();//只有创建了对象才可以访问内部类中的方法。
	}
}

class InnerClassDemo2 
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method();
	}
}

  10.5.2 、匿名内部类：

1. 匿名内部类其实就是内部类的简写格式；

2. 定义匿名内部类的前提：

   内部类必须继承一个类或者实现接口；

3. 匿名内部类的格式： new 父类或者接口(){定义子类的内容}

4. 其实内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。 

abstract class Demo
{
	abstract void show();
}

class Outer
{
	private int x = 3;
	public void function()
	{
		
		new Demo()
		{
			public void show()
			{
				System.out.println("show  :"+x);
			}
		}.show();  //相当于new Inner.show();
	}              //只不过此时的Inner省略了，用其父类名称以及实现其方法；
}


class InnerClassDemo3
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.function();
	}
}

---------------------- ASP.Net+Android+IOS开发 、 .Net培训 、期待与您交流！ ----------------------