Java抽象类、接口和内部类

abstract class Foo{
	private double c;
	public Foo(double c){  //没什么意义，需要被子类重写
		this.c = c;
	}
	public abstract double area();  //抽象方法，没有方法体，大括号也不存在
}
class Sub extends Foo{
	public Sub(double c) {  //需要重写构造方法
		super(c);
	}
	public double area(){
		return 0.0;
	}
}
abstract class Sub2 extends Foo{  //抽象方法继承抽象方法
	public Sub2(double c) {  //需要重写构造方法，不需要重写抽象方法
		super(c);
	}
}

Foo f = new Foo();  //编译错误，抽象类不能被实例化

abstract class Foo{
	private double c;
	public Foo(double c){  //没什么意义，需要被子类重写
		this.c = c;
	}
	public abstract String sayHi();
}
class Sub extends Foo{
	public Sub(double c) {  //需要重写构造方法
		super(c);
	}
	public String sayHi(){
		return "Hello";
	}
}

public class AbstractDemo {
	public static void main(String[] args){
//		Shape s = new Shape(); //编译错误，抽象类不能被实例化
		Shape[] shape = new Shape[4];  //创建Shape数组对象
		shape[0] = new Circle(1);  //向上造型
		shape[1] = new Circle(2);
		shape[2] = new Square(1);
		shape[3] = new Square(2);
		maxArea(shape);  //调用求最大面积方法
	}

	private static void maxArea(Shape[] shape) {
		double max = shape[0].area();
		int maxIndex = 0; //最大面积下标
		for(int i=0;i<shape.length;i++){
			double area = shape[i].area();
			if(area>max){
				max = area;
				maxIndex=i;
			}
		}
		System.out.println("最大面积为:"+max+"所在下标为:"+maxIndex);
	}
}
abstract class Shape{ //抽象类---不完整的类
	protected double c; //周长
	public abstract double area(); //抽象方法---不完整
}
class Circle extends Shape{
	public Circle(double c){
		this.c = c;
	}
	public double area(){  //重写抽象方法---变不完整为完整
		return 0.0796*c*c;
	}
}
class Square extends Shape{
	public Square(double c){
		this.c = c;
	}
	public double area(){
		return 0.0625*c*c;
	}
}

interface Demo{
	public static int x = 100;
	public int y = 50;
	double area();   //默认会加上public abstract修饰
	public abstract void test();
}

public class Test {
	public static void main(String[] args){
		Demo d = new Aoo();   //一个接口类型变量，引用了子类的对象，调用时，调用的是子类对象的具体的实现
		d.test();   //This is Aoo
	}
}

interface Demo{
	public static int x = 100;
	public int y = 50;
	double area();   //默认会加上public abstract修饰
	public abstract void test();
}
class Aoo implements Demo{
	public double area(){
		return 0.0;
	}
	public void test(){
		System.out.println("This is Aoo");
	}
}

interface Foo{
	public void funFoo();
}
interface Goo{
	public void funGoo();
}
interface Hoo extends Foo,Goo{  //接口可以继承一个或多个接口，逗号分隔
	public void funHoo();
}
interface Ioo{
	void funIoo();
}

class Joo implements Hoo,Ioo{  //一个类可以继承多个接口
	public void funFoo(){}  //重写父类的父类的抽象方法
	public void funGoo(){}  //重写父类的父类的抽象方法
	public void funHoo(){}  //重写父类的抽象方法
	public void funIoo(){}   //重写父类的抽象方法
}

public class InterfaceDemo {
	public static void main(String[] args){
//		Inter6 o1= new Inter6();   //编译错误，接口不能被实例化
		Inter6 o2 = new Moo();  //向上造型
		Inter5 o3 = new Moo();
	}
}
//演示接口语法
interface Inter1{
	public static final int NUM = 5;
	public abstract void show();
	double PI = 3.14; //默认public static final修饰
	void say();  //默认public abstract修饰
//	int count; //编译错误，常量必须声明同时初始化
//	void test(){}  //编译错误，抽象方法没有方法体
}

//演示接口实现
interface Inter2{
	void show();
	void say();
}
class Joo implements Inter2{
	public void show(){}
	public void say(){}
}

//演示接口的多实现、继承
interface Inter3{
	void show();
}
interface Inter4{
	void say();
}
abstract class Koo{
	abstract void test();
}
class Loo extends Koo implements Inter3,Inter4{
	public void show(){}
	public void say(){}
	void test(){}
}

//演示接口继承接口
interface Inter5{
	void show();
}
interface Inter6 extends Inter5{
	void say();
}
class Moo implements Inter6{
	public void show(){}
	public void say(){}
}

public class MultiTypeDemo {
	public static void main(String[] args){
		Aoo o1 = new Boo();  //向上造型（自动类型转换）
		Boo o2 = (Boo)o1;     //o1指向的对象就是Boo类型（强制类型转换）
		Inter o3 = (Inter)o1;    //o1指向的对象实现了Inter接口（强制类型转换）
//		Coo o4 = (Coo)o1;    //java.lang.ClassCastException:类型转换异常
		if(o1 instanceof Coo){  //强转建议使用instanceof判断
			Coo o5 = (Coo)o1;
		}
	}
}

interface Inter{}
class Aoo{}
class Boo extends Aoo implements Inter{}
class Coo extends Aoo{}

public class UnionPayTest {
	public static void main(String[] args) {
		ABCATM atm = new ABCATM(); //atm机对象
		UnionPay card = new ABCImpl(); //银联卡
		atm.insertCard(card); //插卡
		atm.payTelBill(); //支付电话费
	}
}
class ABCATM{ //农行ATM机类
	private UnionPay card; //银联卡
	public void insertCard(UnionPay card){ //插卡
		this.card = card;
	}
	public void payTelBill(){ //支付电话费按钮
		if(card instanceof ABC){ //是农行卡
			ABC abcCard = (ABC)card; //强转为农行卡
			abcCard.payTelBill("12345679845", 500);
		}else{ //不是农行卡
			System.out.println("不是农行卡，不能支付电话费");
		}
	}
}

interface UnionPay{ //银联接口
	public double getBalance(); //查询余额
	public boolean drawMoney(double number); //取款
	public boolean checkPwd(String input); //验证密码
}
interface ICBC extends UnionPay{ //工行接口
	public void payOnline(double number); //在线支付
}
interface ABC extends UnionPay{ //农行接口
	public boolean payTelBill(String phoneNum,double sum); //支付电话费
}

class ICBCImpl implements ICBC{ //工行卡
	public double getBalance(){return 0.0;}
	public boolean drawMoney(double number){return true;}
	public boolean checkPwd(String input){return true;}
	public void payOnline(double number){}
}
class ABCImpl implements ABC{ //农行卡
	public double getBalance(){return 0.0;}
	public boolean drawMoney(double number){return true;}
	public boolean checkPwd(String input){return true;}
	public boolean payTelBill(String phoneNum,double sum){
		System.out.println("支付电话费成功");
		return true;
	}
}

public class InnerClassDemo {
	public static void main(String[] args){
		Outer outer = new Outer(100);
		outer.printTime();
		//		Inner g = new Inner();   //编译错误
	}
}

class Outer{
	private int time;
	private Inner inner;
	Outer(int time){
		this.time = time;
		inner = new Inner();
		inner.timeInc();
	}
	public void printTime(){
		System.out.println(Outer.this.time);   //101
		System.out.println(++time);  //102
	}
	class Inner{
		public void timeInc(){
			time++;
		}
	}
}

public class NstInnerClassDemo {
	public static void main(String[] args){
		/*
		 * 1）创建了Inter2的一个子类，但是没有名字
		 * 2）为该子类创建了一个对象，叫o1
		 * 3）大括号中的为子类的类体
		 */
		Inter2 o1 = new Inter2(){	};
		
		/*
		 * 1）创建了Inter2的一个子类，但是没有名字
		 * 2）为该子类创建了一个对象，叫o2
		 * 3）大括号中的为子类的类体
		 */
		Inter2 o2 = new Inter2(){ };
		
		int num = 5;
		/*
		 * 1）创建了Inter1的一个子类，但是没有名字
		 * 2）为该子类创建了一个对象，叫o3
		 * 3）大括号中的为子类的类体
		 */
		Inter1 o3 = new Inter1(){
			public void show(){
				System.out.println("show");
				System.out.println(num);
			}
		};
		o3.show();
	}
}

interface Inter1{
	void show();
}
interface Inter2{ }