黑马程序员-----java入门一DAY13------抽象模板模式 接口interface

---------------------- android培训、java培训、期待与您交流！
----------------------

//模板模式

//抽象类中包含很多的抽象方法，子类必须去覆写！
abstract class Method{
abstract double mul();//返回值类型如果是void的话，下面报错，因为没有返回值，无法引用！
abstract double divid();
void show(){
System.out.println("周长是："+mul());//周长
System.out.println("面积是："+divid());//面积
}
}
//继承抽象类 的子类
class Square extends Method{
double d;

public Square(double d) {
super();
this.d = d;
}

@Override
/*	@Override没什么用，这是你的IDE编辑器为你自动加上去的一个标志，告诉你说
下面这个方法是从父类/接口 继承过来的，需要你重写一次!
这样就可以方便你阅读，也不怕会忘记*/
double mul() {
return d * d;
}

@Override
double divid() {
return 4 * d;
}
}

class Cirle extends Method{
double r;

public Cirle(double r) {
super();
this.r = r;
}

@Override
double mul() {
return 2 * 3.14 * r;
}

@Override
double divid() {
return 3.14 * r * r;
}
}

public class mobanlei {
public static void main(String[] args) {

Square s = new Square(7);//求正方形的周长和面积 使用时将new对象 方法(参数)
s.show();
Cirle c = new Cirle(7);//求圆的周长和面积
c.show();
}
}

以上是关于使用抽象类的方式实现正方形和元的面积 周长求解的 模板抽象方法

模板设计模式

1 抽象父类可以只定义需要使用的某功能方法，具体的实现可以留给子类去完成

2 父类提供的方法只是定义了一个通用的算法，其实现必须以来子类的辅助完成

如果父类的方法不想被子类覆写，那么可以在父类的前面添加final关键字

interface 接口

Java中，能够完成特定功能的，由若干属性和方法组织成的，相对独立的属性和方法的集合。

用途 ：实现类的多继承，以解决Java只能单继承，不支持多继承的问题。

抽象类是从多个类中抽象出来的模板，若要将这种抽象进行的更彻底，就得用到一种

特殊的抽象类——>接口

1 接口之定义了类应当遵循的规范，却不管线这些类内部的具体实现

2 接口只规定了这些类里面必须提供的方法;从而分离了规范和实现.增强了系统

的可扩展性和维护性；

使用接口的好处，拓展性，维护性更好，所以我们在开发中会经常用到接口（相当于

定义了一种标准）

接口规范——>类层——>对象层

USB接口规范A型号鼠标实例化A鼠标

interface定义

接口定义一种规范，规定一个类必须要做什么,但是不管如何实现

具体的格式：

[修饰符]interface 接口名 extends 父接口1，父接口2...

没有构造方法,不能实例化；

接口只能继承接口，不能继承类

接口里没有普通方法，方法全是抽象的；

接口的方法默认修饰符是public abstract；

接口里的字段全是全局变量，默认修饰符是public static final；

接口里的成员包括（主要是前面两个）；

全局常量：

公共的抽象方法

内部类(包括内部类,内部接口,内部枚举类)；

接口的使用

实现接口（支持多实现）

[修饰符] class 类名 implements 接口1，接口2...

接口的实现必须在extends之后；

实现接口的方法必须是public类型

接口不能创建实例，但是可以声明引用类型的变量

此时，引用类型的变量必须指向其实现类对象。

IStudent s = new String();

IStudent s = new StudentImp1()；

接口与类之间的关系

实现关系或者说是继承关系.

可以说实现了接口的方法，也可以说类继承了接口的方法，不同情况下不同的理解

简单工厂模式

构建一个工厂出来,在里面进行生产，用的时候直接拿

好处：屏蔽了不同类实现的差异，提高代码的可扩展性和可维护性

package com.itheima;
/**
* 简单工厂模式
* 当前是模拟手机生产厂商的一个实例
* 思路：
* 1定制手机的共有功能到一个类中 指定标准
* 2实现implements接口
* 3实现具体手机的不同send方法
*
* implements和extends的区别：
* 一个是继承，一个是实现接口，继承这个可以理解为继承父类的方法，
* 父类中的方法可以在子类中用到，super(),实现接口就是在接口中定
* 义了方法，这个方法要你自己去实现，接口可以看作一个标准，比如
* 定义了一个动物的接口，它里面有吃（eat()）这个方法，你就可以
* 实现这个方法implements，这个方法是自己写，可以是吃苹果，
* 吃梨子，香蕉，或者其他的。IMPLEMENTS就是具体实现这个接口。
*
* extends是继承父类，只要那个类不是声明为final或者那个类定
*义为abstract的就能继承，JAVA中不支持多重继承，但是可以用
* 接口来实现，这样就要用到implements，继承只能继承一个类，
* 但implements可以实现多个接口，用逗号分开就行了
* 比如
* class A extends B implements C,D,E
* */

interface Phone{//制定标准，都要实现send()方法
public void send();//这里是先定义一个共有的方法 具体的方法可以交给覆写的子类完成
}

class Iphone implements Phone{
@Override
public void send() {//继承接口的子类 需要重写send功能 实现覆写
System.out.println("Iphone手机在发短信");
}
}

class AndroidPhone implements Phone{
@Override
public void send() {
System.out.println("AndroidPhone手机在发短信");
}
}

class MyPhone implements Phone{
@Override
public void send() {
System.out.println("MyPhone手机在发短信");
}
}
/*标准制定完成后 就要开始实现工厂批量生产模式 建立一个类 实现具体的功能
* 构建一个工厂出来,在里面进行生产，用的时候直接拿*/
class Factory{//实现一个工厂模式 使用show方法
public void show(String type){//传入参数，根据不同的类型个性化定制
if(type.equals("")){//为空的情况，不用往下执行
System.out.println("对不起，类型为空！,请重新输入！");
return;
}
Phone p = null;
if("Iphone".equals(type)){//判断类型
p = new Iphone();
}else if("AndroidPhone".equals(type)){
p = new AndroidPhone();
}else{
p = new MyPhone();
}
p.send();
}
}

public class jiandangongchang {
public static void main(String[] args) {

new Factory().show("Iphone");//调用方法
new Factory().show("AndroidPhone");
new Factory().show("MyPhone");
new Factory().show("YourPhone");
new Factory().show("");
}
}

面向对象编程之适配器模式

使用一个线程的类，但是它的接口不完全复合你的需求，我只想要它其中

的一个方法，不想覆写其他的方法

比如，窗体有变大变小，关闭的行为，但是我们现在只需要关闭行为

package com.itheima;
//适配器模式：只想用其中的某一个方法，用适配器作为中间的过渡

interface Windows{//这里是实现一个interface接口的标准 标准里面有三个没有返回值得方法 最大 最小和关闭
void max();
void min();
void close();
}

//适配器模式，实现接口所有的方法，但是不写方法体！
class AdapterWindows implements Windows{

@Override
public void max() {
}

@Override
public void min() {
}

@Override
public void close() {
}

}

class MyWindows extends AdapterWindows{//这里是继承了接口中适配的方法 覆盖其中的方法实现单个功能的实现去除其他功能
//覆写父类的方法
public void close(){
System.out.println("这个实现的是关闭功能！");
}
}

public class shipeimoshi {
public static void main(String[] args) {
new MyWindows().close();
}
}

接口和抽象类的比较

相同点:

都位于继承的顶端,用于被其他实现或继承;

都不能实例化;

都包含抽象方法,其子类都必须覆写这些抽象方法;

区别：

抽象类为部分长发提供了实现，避免子类重复实现这些方法，提高了

代码的复用性，接口只能包含抽象方法；

一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口；

接口弥补了java的单继承模式

二者的选用

优先选用接口，尽量少用抽象类

需要定义子类的行为，又要为子类提供共性功能时才选用抽象类

小结：

1 接口不能有构造函数，抽象类可以有构造函数

2 abstract可以定义构造函数（包括带函数的构造函数）,因为要保证其子类

在创建的时候能够进行正确的初始化,但是Abstract类不能被实例化。

知识点：如果不可以或者没有创建对象，那么我们必须加上static修饰，不能用对象调用，

就只好用类去调用。

匿名内部类

适合只是用一次的类

不能使抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类

的对象

匿名内部类不能定义构造器，因为匿名内部类没有类名

格式：

new 父类构造器([实参列表]) 或 接口(){

//匿名内部类的类体部分

}

枚举类

使用enum声明，默认直接继承了java.lang.Enum类，而不是Object类

枚举类的对象时固定的，实例个数有限，不可以再new(),枚举对象后可以跟()

枚举元素必须位于枚举类体中的最开始部分，枚举元素后要有逗号与其他成员分割

枚举类的构造方法的权限修饰符默认是private

一旦枚举对象类都提供一个静态的value()方法（返回该枚举类所有对象组成的数据）

便于遍历所有枚举对象

所有枚举类都提供一个静态的valueOf（String name）方法,返回枚举类中对象名

等于name的对象

/*public enum Color{
RED(), GREEN(){}, BLUE{};一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;
}

*/
/*使用枚举的方法实现绿蓝黄三种颜色的不同调用*/
package com.itheima;
//枚举

enum Color{//enum 制定一个枚举类 类中包括Green,Blue,Yellow;三种颜色
Green,Blue,Yellow;//枚举对象后面可以跟()，如果跟的是{}那么是枚举匿名内部类对象

@Override
public String toString() {//toString() 返回该对象的字符串表示
String ret = super.toString();
switch (this) {
case Green:
ret = "绿色";
break;

case Blue:
ret = "蓝色";
break;

case Yellow:
ret = "黄色";
break;

default:
break;
}

return ret;
}

}

class Personp{
Color c = Color.Blue;
void show(){
System.out.println(c);
}
}

public class enumshili {
public static void main(String[] args) {
/*values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象；*/
Color []color = Color.values();
for (Color c : color) {//这里使用了for的遍历方法 for each
System.out.println(c);
}
/*以上for等同于
for (int i = 0; i < Color.length; i++) {
String s = Color[i];
System.out.print(c);
}*/
new Personp().show();
}
}

枚举内部类接口的两种方式：

在枚举类中实现接口的抽象方法

在枚举匿名内部类中实现接口的抽象方法

interface I{

void show();

}

enum Color implements I{

RED(){

public void show(){},

}，

GREEN(){

public void show(){},

}，

BLUE(){
public void show(){},
};
}

enum Color implements I{

RED(),GREEN,BLUE;

public void show(){

}

}

总结：

枚举不可以new();即便是反射也不可以！

一个类如果没有构造方法，那么一定有相对应的某个方法获取对象！

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------