java 基础知识十一 抽象类和 接口

java  基础知识十一   抽象类和 接口  

1、抽象类

抽象类和接口也是多态的体现方式

抽象类：类中没有足够信息描述具体的对象，这样的类称为抽象类

抽象类分两种展现方式 abstract class一种是接口 interface  

2、abstract class 一般描述为抽象类  interface 一般描述为接口

抽象类定义

注意：在抽象类中的方法不一定是抽象方法,但是含有抽象方法的类必须被定义成抽象类 

 

区别和对比：
　     1.abstract class在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
　     2.在abstract class中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，     不 过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。
3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。 
　     4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
　     5.接口中定义的变量默认是public static final型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly型，其值可以在子类     中 重新定义，也可以重新赋值。 
6.接口中的方法默认都是 public,abstract类型的。

3、内部类 
内部类就是定义在外部类中的类，类名不与文件名相同，可以是静态static的，也可以是其他修饰符
内部类一旦编译成功就和外部类成为不同的两个类，区别为outer.class和outer$inner.class两类

成员内部类：外部类的成员，必须先创建了外部类对象 才能创建成员内部类对象 不可以有static数据和属性
局部内部类：定义在方法和作用域内的类，在作用域的范围内有效
静态内部类：定义为static的内部类，可以有static数据和属性
匿名内部类：没有名字而且只能使用一次的内部类，必须继承一个父类或者实现一个接口

附件 

1、抽象类

package com.vivi.study.abstracttest;

abstract class AbstractHello {

   private String type;
   // 抽象方法 只声明 不实现  交给继承者实现 
   abstract void method1();
    void method2(){
    	System.out.println("我是非抽象方法");
    };
}

2、抽象类子类 包含内部类 在内部类测试代码中展现

package com.vivi.study.abstracttest;
/*
 * 抽象类子类
 * 实现父类方法
 * 成员内部类
 * 静态成员内部类
 * 局部内部类
 */
public class AbstractHelloSub extends AbstractHello{

	@Override
	void method1() {
		System.out.println("实现父类抽象方法 ");
	}

	public subClass getSubClass(){
		return new subClass();
	}
	
	// 成员内部类
	public class subClass{
//		不能含有static 变量和方法 会报错
//		public static int age=1;

		public int getSubName() {
			return subName;
		}
		public void setSubName(int subName) {
			this.subName = subName;
		}
		private int subName;
		public void subMethod(){
			System.out.println("");
		}
	}

//	局部内部类 定义在方法中的内部类
	public void getClassMethod(int mage){
		class SubClassInMethod{
			
			public SubClassInMethod(int age){
				this.setAge(age);
				System.out.println("局部内部类演示"+age);
			}
			
			private int age;

			public int getAge() {
				return age+2;
			}

			public void setAge(int age) {
				this.age = age;
			}
		}
		
		SubClassInMethod mSubClassInMethod=new SubClassInMethod(3);
		System.out.println("局部类方法调用"+mSubClassInMethod.getAge());
	}
	
	
	// 静态内部类 可以有静态变量和静态方法 
	public static class staticSubClass{
		public static int age=1;
		private String name;
		
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		
		public static void getMName(String name1){
			System.out.println("来自静态内部类的"+name1);
		}
	}
}

3、抽象类测试

package com.vivi.study.abstracttest;

public class TestAbsctract {

	public static void main(String[] args) {
		// 抽象类不能直接创建对象 否则编译不通过  
//		Cannot instantiate the type AbstractHello
//		AbstractHello abstractHello1=new AbstractHello();
		
		
//		抽象类可以通过对象引用指向非抽象子类对象  
//		类比下动态绑定就知道了  父类   父类引用 =new 子类();    这也是多态的一种形式
		AbstractHello abstractHello2=new AbstractHelloSub();
		abstractHello2.method1();
		
//		但是抽象类 可以通过 隐式内部类重写其抽象方法来new对象  
		AbstractHello abstractHello3=new AbstractHello() {
			@Override
			void method1() {
				System.out.println("抽象类创建对象  无法通过编译");
			}
		};
		abstractHello3.method1();
	}
}

4、接口类

package com.vivi.study.abstracttest;

public interface InterfaceHello {

	/*
	 * 不能有成员方法
	 * 不能有静态代码块
	 * 对行为（方法）抽象
	 * 使用implement
	 */
	int type=1;//相当于  public static final int type=1;
	void sayHello();// 相当于abstract void sayHello();
}

5、接口实现类

package com.vivi.study.abstracttest;

public class InterfaceHelloSub implements InterfaceHello{

	@Override
	public void sayHello() {
		System.out.println("来自接口的public static final变量"+InterfaceHello.type);
	}
}

6、接口 抽象类 内部类测试

package com.vivi.study.abstracttest;

public class InterfaceAndAbstractTest {

	public static void main(String[] args) {
	
  // 内部类测试
		//1、匿名内部类

		//内部类 接口方式==动态引用，将InterfaceHelloSub实例向上转型为InterfaceHello的引用
		InterfaceHello interfaceHello0=new InterfaceHelloSub() ;
		interfaceHello0.sayHello();
		//匿名内部类 接口方式
		InterfaceHello interfaceHello=new InterfaceHello() {
			
			@Override
			public void sayHello() {
				System.out.println("匿名内部类 接口方式");
			}
		};
		interfaceHello.sayHello();
		
		//内部类 抽象类方式==动态引用，将AbstractHelloSub实例向上转型为AbstractHello的引用
		AbstractHello abstractHello0=new AbstractHelloSub() ;
		abstractHello0.method1();
		//匿名内部类 抽象类形式 abstract 类
		AbstractHello abstractHello=new AbstractHello() {
			
			@Override
			void method1() {
				System.out.println("匿名内部类 抽象类形式 abstract 类");
			}
		};
		
		abstractHello.method1();
		
//		2、成员内部类
		
//	    成员内部类需要先创建了外部类，才能创建它自己的
//		AbstractHelloSub.subClass sub=new AbstractHelloSub.subClass(); 这个会报错
		AbstractHelloSub sub1=new AbstractHelloSub();
		AbstractHelloSub.subClass sub2=sub1.getSubClass();
		sub2.subMethod();
		
		
//		3、局部内部类 定义在方法中的内部类
		sub1.getClassMethod(2);
		
//		4、静态内部类
		AbstractHelloSub.staticSubClass.getMName("张三");
	}
}