黑马程序员-面向对象（抽象类、接口与内部类）-优快云博客

本文链接：https://blog.youkuaiyun.com/dsa63/article/details/13725217

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

抽象类

当描述一个事物的时候，如果不能确定功能函数如何定义，那么该类就可以定义为抽象类，功能函数应该描述为抽象函数。

抽象类的格式：

Abstract class Demo{

      成员属性；

      非抽象方法（）{}；

      abstract抽象方法；

}

抽象的优点

1：提高代码复用性

2：强制子类实现父类中没有实现的功能

3：提高代码的扩展性，便于后期的代码维护

抽象方法存在于抽象类和接口类，有抽象方法的不一定是抽象类，也可以是接口类。

问题：抽象类可以没有抽象方法吗？

答：抽象类也可以没有抽象方法，但是这样的抽象类无实际使用意义，除非是想要一个类不能被直接实例化，则可以定义为无抽象方法的抽象类

抽象类需要注意的地方

（1）抽象类和抽象方法必须被abstract修饰

（2）抽象类中的抽象方法必须被子类实现

（3）抽象类可以同时存在抽象方法和非抽象方法

（4）抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是实体类的构造函数不能被私有化

（5）非抽象类在继承抽象类的时候，必须要把所有的抽象方法实现

（6）抽象类继承抽象类的时候，可以不用实现父类的抽象方法

（7）抽象方法不能用private关键字修饰，因为抽象方法是必须要被继承的，如果被私有修饰，那么将对子类不可见

（8）抽象方法也不能static修饰，因为用static修饰的方法可以用类名调用，但是抽象方法是没有被实现的，会出错，所以…

（9）抽象方法不能用final修饰，因为被final修饰的不能被继承，而抽象方法是必须要被继承的

（10）抽象类可以有构造方法，也可以不写构造方法，抽象类虽然不能创建对象，但构造方法是有意义的，可以为子类初始化对象，简化代码

接口：

接口的使用格式：

interface 接口名
{
属性
抽象方法
}

接口的作用（红色为主要作用）

程序的解耦

提供了标准和规范

弥补了类的单继承限制

扩展了功能

接口需要注意的地方：

（1）interface接口的成员属性全是静态常量，默认的修饰符为public Static final，如果没有写，编译的时候，编译器自动加上，一般不定义静态常量

（2）接口中的成员方法全部是抽象方法，默认修饰符为public abstract，如果没有写上，编译器自动加上

（3）接口不可以存在构造函数，不能创建对象

（4）在实现接口的时候，要把接口中的所有抽象方法覆写

（5）接口中不允许存在非抽象的方法（这和抽象类有区别），因为在编译时期，编译器会给所有的方法统一加上默认的修饰符public abstract

接口的多实现

前面说到java不支持多继承，但是接口支持多实现，这个就是对不支持多继承的一个补偿

那这个的原因是什么呢

因为继承有方法体，如果允许继承多继承，如果有继承的多个类中有同名的方法，那么可能就会产生冲突

但是接口就有一点区别，却别就是在于接口里面的方法没有方法体，即使有同名的方法，也不影响，只能在覆写的时候，由使用者自定义实现内容

内部类

内部类的使用格式

格式：

外部类名.内部类名变量名 =外部类对象.内部类对象;

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

例子：

class Outer
{
   	private int x = 3;
   	class Inner//定义在外部类成员位置上的内部类
   	{
      		int x = 4;
      		void function()
      		{
         		int x = 6;
         		System.out.println("innner :"+Outer.this.x);
      		}
   	}
   	void method()
   	{
      		Inner in = new Inner();
      		in.function();
   	}
}

class  InnerClassDemo
{
   	public static void main(String[] args) 
   	{
      		Outer.Inner in = new Outer().new Inner();
      		in.function ();
   	}
}

内部类的访问规则：

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

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

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

问题1：类能不能被私有修饰

答：是可以的，因为内部类可以被私有修饰，当内部类处于外部类的成员位置的时候，可以私有修饰

但是外部类是不允许被私有修饰的

在这要注意Static修饰，修饰了内部类之后，如果内部调用的方法没有被静态修饰的话，不能被类名直接调用

回顾了一下

static 的使用规则

（1）static修饰属性，如static int num；那么这个num就是属于全局属性，所有对象共享的，可以被直接类名调用，Person p1 = newPerson();既可以p1.num = 10;也可以Person.num = 10;这样调用

（2）static修饰方法，

int num;

public static fun(int inf)

{

this.num = inf;

}

这样是错误的，因为static修饰的方法只能调用static修饰的属性，而num没有被static修饰

其实我这之前有一个误区，一直学到内部类才察觉到，就是以为static修饰的方法，是修饰了一整个方法体，连带方法体里面的属性也被static给修饰了，其实不完全是，static只是修饰了方法名，此时方法可以通过类名调用，我过去是在于以为方法内部的属性同样必须要经过static修饰或者已经在方法外部定义为static，这个方法才能编译成功。正确的说法，所谓调用，是外部定义的。被static修饰的方法，去使用外部的属性，这叫调用，在方法体里面定义的属性，属于局部的变量，则不属于调用，所以，不需要经过static修饰，直接可用，如果外部想用该属性，必须经过内部类的类名调用，也不能直接用，因为它不属于全局属性，属于局部变量

（3）static修饰类，其实应该也就是指内部类

基于java的面向对象思想，其实可以这样想，只要把内部类看成是一个成员方法或者成员变量即可，那么使用规则如出一辙，区分好调用了内部类中自己定义的方法和属性即可。

注意：内部类的成员变量和成员函数不能单独声明为静态，只有把内部类声明为static，这个内部类才能被静态声明的方法和属性，否则编译会报错，某些内部类不能被static修饰，下面说到

内部类定义在局部时的注意事项：

（1）内部一般只出现在外部类的成员位置上，在这个位置上，可以被static修饰，但是也有例外，就是出现在外部类的方法里面，再定义一个内部类，这个内部类就不是出现在外部类的成员位置上了，而是出现在外部类成员位置的内部位置，这是局部位置，出现在这个位置的内部类，不可以被static修饰，也即是说，只有在外部类成员位置上的内部类才能被static修饰，局部内部类不能被static修饰

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

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

class Outer
{
	int x = 3;
	void method(final int a)
	{
		final int y = 4;  //内部类要访问这个变量，必须用finally修饰
		class Inner   // 此时内部类定义在局部位置
		{
			void function()
			{
				System.out.println(y);
			}
		}
		new Inner().function();
	}
}

匿名内部类:

匿名内部类的格式

new 接口或者抽象类()

{

覆写抽象方法

}

示例：

class Inner extends AbsDemo
{
	int num = 90;
	void show()；
	{
		System.out.println("show :"+num);
	}
}
可以写成内部类形式
new AbsDemo
{
	int num = 90;
	void show()
	{
		System.out.println("show :"+num);
	}
}.show();//红色部分是一个对象

1，匿名内部类其实就是内部类的简写格式。

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

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

问题：那怎么知道到底是继承还是实现呢？

答：使用者自己知道

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

4，其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

匿名内部类的实践

class Test
{
	static Inter function()//返回值为Inter的一个方法
	{
		return new Inter()
		{
			void method();
		}            //红色部分是一个Inter类型的匿名内部类
		//匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
	}
	class Demo interface Inter//此时接口是Inter，内部类名为Demo
	{
		void method();
	}
}
public class InnerTest
{
	public static void main(String args[])
	{
		Test.function().method();
	}
}

上述代码中，Test.function().method();可以分解成三部分

Test.function():Test类中有一个静态的方法function，因为通过类名调用

.method():function这个方法运算后的结果是一个对象。

而且是一个Inter类型的对象。

因为只有是Inter类型的对象，才可以调用method方法。

问题：为什么成员内部类不能有静态属性呢

首先明确内部类有四种

（1）成员内部类

（2）局部内部类

（3）静态内部类

（4）匿名内部类

答：这里说的是成员内部类，那么就排除了处于成员位置上的静态内部类，其实说的就是内部类的方法和属性不能单独设置为静态，要设置，可以，必须把内部类变成静态内部类，一起设置

建立内部类对象时应注意：
在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）
而在外部类的外部，要生成（new）一个非静态的内部类对象，需要首先创建一个外部类对象（外部类可用），然后在生成一个内部类对象。
Outer.Inner in=new Outer.new.Inner()。

注意：生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；//这个是静态内部类的创建方式，静态内部类必须要这样声明
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类