重载 & 抽象类 & 接口

重载

1.概念

重载是友好的，
它不要求你在调用一个方法之前转换数据类型，它会自动地寻找匹配的方法。
方法的重载是在编译时刻就决定调用哪个方法了，和重写不同。最最常用的地方就是构造器的重载。

2.使用重载的注意事项

1)在同一类中
2)方法名相同
3)参数列表(类型个数顺序)不同
4)返回值无关

示例：

package com.ambow.test;
public class Demo {
	/*
	 * 重载的方式：
	 * 	1.在同一个类中
	 * 	2.方法名相同
	 * 	3.与返回值无关
	 * 	4.参数列表不同（个数顺序类型）
	 * */
	//方法一
	public void myMedth() {

	}
	//方法二
	//方法一与方法二的区别在与参数个数不同
	public void myMedth(int i) {

	}
	//方法三
	//方法二与方法三的区别在与参数类型不同
	public void myMedth(String name) {

	}
	//方法四
	//方法三与方法四的区别在与参数个数不同
	public void myMedth(String name,boolean flag) {

	}
	//方法五
	//方法四与方法五的区别在与参数顺序不同
	public void myMedth(boolean flag,String name) {
		
	}
}

示例（测试类）：

package com.ambow.test;
public class Test {
public static void main(String[] args) {
	//重载的方法只有在方法调用传进来的参数才能确定是那个方法
	Demo d=new Demo();
	d.myMedth("123",true);
}
}

7.7 抽象类

7.7.1 抽象类的概念

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

7.7.2 抽象类的使用

含有一个或多个抽象方法的类，不能被实例化。抽象类的使用方法是使其他类能够从它继承，并且一定要实现抽象类中抽象方法使这个类具体实例化。(定义了一个或者多个抽象方法的类。因为有抽象方法，所以不能实例化。继承了抽象类的子类可以通过实现抽象方法使得自己成为具体类（从而可以被实例化）。

7.7.3 使用抽象类的注意事项

---

1.抽象类必须用abstract关键字来修饰；抽象方法必须用abstract类修饰。
2.抽象类不能被实例化，也就是不能用new关键字去产生对象。
3.抽象方法只需声明，不需实现。
4.含有抽象方法的类必须被声明为抽象类，抽象类的方法必须被子类覆盖所有的抽象方法后才能被实例化，否则这个子类还是一个抽象类
5.abstract 不能与final并列修饰同一个类 。
6.abstract不能与private,static,final并列修饰同一方法。
7.abstract 方法必须位于 abstract 类中。
8.abstract类中可以不包含 abstract 方法。
9.abstract类不能实例化，但抽象类可以有构造函数

---

示例：

package com.ambow.test;
public abstract class AbstractDemo {	
public AbstractDemo(){
		
}
/**
 * 1.抽象类或者抽象方法都必须使用abstract关键字来修饰
 * 2.抽象类不能被实列化
 * 3.抽象类只需要声明不需要实现
 * 4.含有抽象方法的类，必须声明为抽象类
 * */
	/**
	 * 1.final不能与abstract同时修饰一个类
	 * 2.abstract不能与private,static,final并列修饰同一方法
	 * 3.abstract 方法必须位于 abstract 类中
	 * 4.abstract类中可以不包含 abstract 方法（抽象类中可以有普通方法）
	 * 5.abstract类不能实例化，但抽象类可以有构造函数。
	 * 
	 * */
	//抽象方法
	public abstract void singer();
	public abstract void test();
	//抽象类中可以有普通方法
	public void say(){
		System.out.println("123321");
	}
	// public static void main(String[] args) {
  	//抽象类不能被实列化
 	//AbstractDemo at=new AbstractDemo();
	// }
}

示例（测试类）：

package com.ambow.test;
public class Demo extends AbstractDemo {
/**
 * 5.抽象类中抽象方法必须被子类全部覆盖（重写）后，子类才能实列化
 * 只要有一个抽象方法没有被重写那么这个子类还是一个抽象类
 * */	
	public Demo(){
		super();
	}
	@Override
	public void singer() {
		// TODO Auto-generated method stub
		System.out.println("222222222222");
	}
	@Override
	public void test() {
		// TODO Auto-generated method stub
		
	}
	public static void main(String[] args) {
		//抽象类不能被实列化
		//AbstractDemo ad=new AbstractDemo();
		//重写完父类中所有的抽象方法子类才能实列化
		Demo d=new Demo();
		d.say();
		d.singer();
	}	
}

7.8 接口

接口(interface) 就是方法定义和常量值的集合，是一种特殊的抽象类如果抽象类的所有方法都是抽象的，就可以用接口来实现。接口在语法上有些类似于类，它定义了若干各抽象方法和常量，形成了一个属性的集合，该属性集合通常对应某一种功能，实现类似于多重继承的功能。

7.8.1 接口的基本思想

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，Constance 运算符可以用来决定某对象的类是否实现了接口。
接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误）， 而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关 键字，比如private、protected、static、 final等修饰会报编译错误），并且接口中所有 的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以 隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。

7.8.2 接口的使用

接口的使用与类的使用有些不同。在需要使用类的地方，会直接使用new关键字来构建一个类的实例，但接口不可以这样使用，因为接口不能直接使用 new 关键字来构建实例。
接口必须通过类来实现(implements)它的抽象方法，然后再实例化类。类实现接口的关键字为implements。如果一个类不能实现该接口的所有抽象方法，那么这个类必须被定义为抽象方法。
不允许创建接口的实例，但允许定义接口类型的引用变量，该变量指向了实现接口的类的实例。一个类只能继承一个父类，但却可以实现多个接口。
实现接口的格式如下：
修饰符 class 类名 extends 父类 implements 多个接口 {
实现方法
}

7.8.3 接口的继承

接口也具有继承性，同样它也可以继承父类所有的属性和方法。与类的继承不同的是，一个接口可以继承多个父接口，它们之间用逗号隔开，子接口将继承父类接口的所有属性和方法。
类不支持多重继承，接口可以有多重继承。

示例（父接口）：

package com.ambow.test;
/**
 *接口的定义：
 *		public interface 接口名{
 *		常量；（接口中的常量默认被public static final修饰）
 *		方法；（接口中的方法默认被public abstract修饰）
 *		} 
 * */
public interface A {
	public void testA();
}

示例（父接口）：

package com.ambow.test;
public interface B {
	public void testB();
}

示例（接口的继承）：

package com.ambow.test;
/*
 * 1.类中不可以有多继承，而接口中可以使用，继承的父类用逗号隔开，实现了多继承
 * 2.接口不能实列化，而且也不可以直接调用，（因为接口不是静态的），也不能和static final 一起修饰方法
 * */
public interface USB extends A,B {
//	int i=23;	
//	public void say();
}

示例（接口的实现）：

package com.ambow.test;
/**
 * 利用类类对接口进行实现，实现一个接口我们必须使用implements关键字
 * 
 * */
public class USBImpl implements USB {

	@Override
	public void testA() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void testB() {
		// TODO Auto-generated method stub
		
	}
}

7.8.4 接口的实现

使用implements 关键字表示实现；一个类可以在继承一个父类的同时，实现一个或多个接口；一个类可以全部实现接口的抽象方法,也可以实现部分接口的方法.部分实现的类必须是abstract修饰的类。

示例（父接口）：

package com.ambow.test;
public interface C {
	public void testC();
}

示例（父接口）：

package com.ambow.test;
public interface D {
	public void testD();
}

示例（父类）：

package com.ambow.test;
public class FatherImpl {

}

示例（实现）：

package com.ambow.test;
/**
 * 1.一个类可以在继承一个父类的同时，可以实现一个或者多个接口
 * 2.如果一个类实现多个接口，那么必须实现多个接口中的所有方法。否则就必须将该类定义为抽象类
 * */
public class Impl extends FatherImpl implements C,D {

	@Override
	public void testD() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void testC() {
		// TODO Auto-generated method stub
		
	}
	public static void main(String[] args) {
		Impl i=new Impl();
		i.testD();
	}

}

7.8.5 接口的意义

让类不必受限于单一继承的关系，而可以灵活的同时继承一些共有特性，从而达到多重继承目的。通过接口使得不同层次，甚至不相关的类可以具有相同的行为。

示例：

package com.ambow.test;
import com.ambow.a.A;
import com.ambow.b.C;
/**
 * 接口的意义：
 * 1.接口可以代表规范
 * 2.可以协同开发（即便没有具体实现方法的内容，也可以暂时把方法调用过来），协同开发时可以提高开发效率（接口和实现类可以分开写）
 * 3.易拓展（可以使用多态,一个接口类型的引用可以指向多个实现类实列）
 * */
public class Impl implements A,C {

	@Override
	public void testC() {
		// TODO Auto-generated method stub	
	}

	@Override
	public void testA() {
		// TODO Auto-generated method stub
	}
}

说明：接上面的案例。

7.8.6 接口的引用

接口可以作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中，通过这些引用类型的变量我们可以访问实现类所实现的接口中的方法，java运行的时候系统动态的确定该使用那个类的方法。
把接口作为一种数据类型，我们可以不需要了解对象所对应的具体的类，而着重于他们的交互。
多态的表现形式: 1 基于类的继承 2 基于接口的实现。

7.9 接口和抽象类的总结

抽象类

抽象类必须用 abstract 修饰，子类必须实现抽象类中的抽象方法，如果有未实现的，那么子类也必须用 abstract 修饰。抽象类默认的权限修饰符为 public，可以定义为 public 或 procted，如果定义为 private，那么子类则无法继承。抽象类不能创建对象
抽象类和普通类的区别
抽象类必须用public、procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public；抽象类无法创建对象，如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么必须定义为 abstract

接口

接口中的变量隐式的使用 public static final 修饰，并且需要给出初始值。方法隐式的使用 public abstract 修饰(并且只能是 public ，如果是 private，procted，那么就编译报错)。接口中的方法默认不能有具体的实现（JDK1.8开始可以有默认的实现）
接口和抽象类的区别
抽象类只能继承一次，但是可以实现多个接口
接口和抽象类必须实现其中所有的方法，抽象类中如果有未实现的抽象方法，那么子类也需要定义为抽象类。抽象类中可以有非抽象的方法
接口中的变量必须用 public static final 修饰，并且需要给出初始值。所以实现类不能重新定义，也不能改变其值。
接口中的方法默认是 public abstract，也只能是这个类型。不能是 static，接口中的方法也不允许子类覆写，抽象类中允许有static 的方法