15.Java学习笔记第十五节——面向对象＜下＞（二）（尚硅谷视频整理）-CSDN博客

本文链接：https://blog.csdn.net/Hhuaahua/article/details/108266040

一、抽象类与抽象方法（第一条主线）

1.定义

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。（理解：当子类越来越多，功能越来越强时，我们在创建对象时就直接创建子类的对象，而不必再创建父类对象，此时就干脆不再让父类允许创建对象，那么就用一个关键字来修饰父类，此时父类就成为一个抽象类。）

2.特点

用abstract关键字来修饰一个类，这个类叫做抽象类。
用abstract来修饰一个方法，该方法叫做抽象方法。

3.abstract关键字

1.abstract修饰类

（1）此类不能被实例化。
（2）抽象类中一定有构造器，便于子类实例化调用。
（3）开发中一般会提供抽象类的子类，让子类对象实例化，完成相关功能。

2.abstract修饰方法

（1）只有方法的声明，没有方法体。如 public abstract void talk();抽象方法不能被直接调用。
（2）含有抽象方法的类必须被声明为抽象类。反之，抽象类中可以没有抽象方法。
（3）抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法（包括间接父类的方法），仍为抽象类，需要用abstract 修饰。

3.abstract使用注意

（1）不能用abstract修饰变量、代码块、构造器。
（2）不能用abstract修饰私有方法、静态方法、final的方法、final的类。

4.匿名类

（1）由于抽象类不能实例化，假设 Person 是一个抽象类，那么 Person p= new Person (); 是错误的写法，但是 Person p= new Person () { }; 方法体内重写 Person 的抽象方法，此时是不报错的。这时就说创建了一个匿名子类的对象p。（此时类的种类不清楚，但是 Person 的子类，没有名字）

（2）联想之前学过的匿名对象：method(new Student()); ，类就是Student，而对象名不清楚；
Worker worker =new Worker(); method1(worker);这是非匿名的类非匿名的对象，因为类名（Worker）和对象名（worker）都清楚；
method1(new Worker);此时是非匿名的类匿名的对象，类名（Worker）清楚，对象名不清楚。

（3）更省事的方法，匿名类的匿名对象： method1(new Person () { });在{}里重写 Person 的抽象方法即可。

5.应用：模板方法设计模式(TemplateMethod)

解决的问题：

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

二、接口interface（第三条主线）

1.理解

（1）一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

（2）另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

（3）接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。

（4）接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

2.定义

接口(interface)是抽象方法和常量值定义的集合。

3.特点

（1）用interface来定义。

（2）接口是与类并列的两个结构。

（3） JDK7及以前，接口中只能定义全局常量（public static final，但是书写时可以省略）和抽象方法（public abstract）。

interface Flyable{
	public static final int ID = 1;
}

和

interface Flyable{
	 int ID = 1;
}

都是可以的。同理，public abstract void start(); 和 void start(); 也都正确。

（4） JDK8 新特性，除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。

public interface CompareA
{
	public static void method1() //静态方法
	{
	}
	
	public default void method2() //默认方法
	{
	}
	public  void method3() //默认方法
	{
	}
}
class SubClass implements CompareA{
}

<1> 接口中定义的静态方法只能通过接口来调用。

SubClass s=new SubClass();
s.method1(); //错误
SubClass.method1(); //错误
CompareA.method1(); //正确

<2> 通过实现类的对象可以调用接口中的默认方法。

<3> 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写后的方法。

<4> 类优先原则：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么在子类没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-------------->类优先原则

<5> 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口且没有重写方法时，会出现：接口冲突。要想不冲突，只能在实现类中重写此方法。

（5）接口中没有构造器，即不能实例化。

（6）接口通过让类去实现（ implements）接口的方式来使用。如果实现类覆盖（重写，一般称为实现）了接口中的所有抽象方法，则此实现类就可以实例化；否则仍为一个抽象类。class Plane implements Flyable{ } 括号里重写接口 Flyable的方法。

（7） Java 可以实现多个接口,要想实例化，必须实现接口中的所有抽象方法。

interface Flyable{
} 

interface Attackable{
} 

class Bullet implements Flyable,Attackable{
}

（8）继承和接口的顺序 class AA extends BB implements CC，DD，EE{ }

（9）接口也可以继承其它接口，可以多继承。

interface AA{
} 

interface BB{
} 

interface CC extends AA,BB{
}

（10）接口的使用体现多态性。（例如一个方法的形参是接口类型，由于接口不能实例化，所以只能提供其实现类的对象，即体现了多态性）

（11）创建接口的匿名实现类对象，同abstract的匿名类的创建方式。

4.补充

JDBC 里定义了大量接口，通过Java程序通过 JDBC 来操作数据库。(为什么不通过程序直接操作数据库呢？这是因为对于同样的操作不同的数据库可能的操作方法不一样。例如添加数据，可能MySQL数据库操作是add，但是对于Oracle可能是insert，这就导致需要编写大量代码，代码的迁移工作量巨大。所以这时就体现出通过JDBC操作的优点。

JDBC里定义的大多是接口，程序可以写一个方法，参数为JDBC里的接口，在操作数据库时就可以传入具体数据库的实现类对象，体现了多态性。而所有实现类的集合放入对应的Driver（图中）中，就称为驱动。（如图，MySQL Driver是MySQL的驱动）
驱动可以看做接口实现类的集合。
Java程序员不必面向数据库编程，而是面向接口编程。

5.应用：代理模式(Proxy)和工厂模式

1.代理模式(Proxy)

（1）定义代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

2.工厂模式

6.抽象类与接口的异同

在这里插入图片描述

三、类的内部成员之五：内部类

1.理解

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

2.特点

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

3.分类

（1）成员内部类（static成员内部类和非static成员内部类）

class 外部类
{
	 class 成员内部类
 	{
 	}
 }

成员内部类作为类的成员的角色：

可以被4种权限修饰；
可以调用外部类的结构；
Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

成员内部类作为类的角色：

可以在内部定义属性、方法、构造器等结构；
可以声明为abstract类，因此可以被其它的内部类继承；
可以声明为final的，不被继承。

（2）局部内部类（不谈修饰符）：方法内、构造器内、代码块内

声明局部内部类：

class 外部类
{
	方法()
	{
		class 局部内部类
		{ 
		} 
	} 	
	
		{
			class 局部内部类
			{ 
			} 
		}		
}

4.使用

（1）实例化成员内部类的对象

class Person
{
	static class Dog //静态成员内部类
	{
	}
	class Bird //非静态成员内部类
	{
	} 
}

实例化：

对于静态成员内部类 Person.Dog dog=new Person .Dog();

对于非静态成员内部类： Person.Bird bird=new Person .Bird(); 是错误的，必须有实例才可以调用其内部结构：Person p=new Person(); Person.Bird bird=p.new Bird();

（2）如何在成员内部类中区分调用外部类的结构

public class Outer
 {
	private int s = 111;
	public class Inner 
	{
		private int s = 222;
		public void mb(int s) 
		{
			System.out.println(s); // 局部变量s
			System.out.println(this.s); // 内部类对象的属性s
			System.out.println(Outer.this.s); // 外部类对象属性s
		 } 
	}
}