抽象类,接口和内部类

抽象类

类中有抽象函数的类就被称为抽象类。（模糊不清的类 不具体的类）

• 当我们在抽取一个父类的时候，发现子类当中的一些共同方法在父类中无法进行具体的实现
• 并且这些方法只能在子类中具体实现时，父类当中的这些函数就只保留函数声明即可，不必写函数体
• 那么此时这个函数就是 抽象函数！ 有抽象函数的类 就是抽象类！但抽象类不一定有抽象函数

abstract class Animal{

     public abstract void eat();
     abstract void jiao();
     public void see();//抽象类也可定义非抽象函数
     ......

}

 注意点：

1. 抽象类能否创建对象？不能 对象本身是一个具体的东西 而抽象类中含有不具体的内容
2. 抽象类必须作为父类存在吗？必须 抽象类就等着被继承呢！
3. 抽象类和一般类有什么区别？就是一般类的特殊情况
4. 唯一的区别只在于抽象类中有抽象函数！
5. 抽象类中必须有抽象函数吗？不一定 AWT界面开发
6. abstract这个关键字不能和那些关键字共存？
7. private 抽象函数就等着被子类重写实现呢！
8. static  静态是优先于对象存在的，在加载静态数据的时候 肯定是具体的数据

               

接口

接口的由来：当一个抽象类中 所有的函数都是抽象的时候，那么我们就可以将这个抽象类
用另外一种表现形式-接口      <那也说明了抽象类中不一定全都是抽象函数>也可能有具体函数

接口与接口之间的关系：继承关系，多继承关系。一个接口可继承多个接口，这和类的单继承差别较大

 

接口与类之间的关系：类用来实现接口(重写接口当中的所有方法)关键字implements来实现。多实现---一个类可实现多个接口。

 

具体如代码所示

package part1.接口;

public class InterfaceDemo1 {
	public static void main(String[] args) {
		demo4 d=new demo4();
		d.show();
		d.sing();
		System.out.println(interfaceA.a);//接口中定义的变量只能通过接口.变量名去掉用
		demo3 d3=new demo3();//实现了接口d中的爸爸b和爷爷c中相关方法
		d3.eat();
		d3.sleep();
		interfaceB.see();
		interfaceC.see();
	}
}

interface interfaceA{
	public abstract void show();
	void sing();
	public static final int a=1;
	int b = 3;
}
interface interfaceB{
	void eat();
	public static void see(){
		System.out.println("看花花...");
	}
}
interface interfaceC extends interfaceB{
	void sleep();
	public static void see(){//接口中可以定义静态函数，但是这个静态函数只能有本接口来调用。接口名.静态函数名
		//只能是通过接口调用 不会继承给子类也就是虽然   c继承自接口b但是调用的静态函数自是它自己的而不是父类的。。否则会报错 
		System.out.println("看妹妹...");
	}
}
interface interfaceD extends interfaceB,interfaceC{
	//接口与接口之间是多继承关系
}
abstract class demo5 implements interfaceD{
	//2.第2种实现接口的方法，这个类抽象成抽象类,实现接口。然后其他类继承这个父类抽象类
	
}
class demo6 extends demo5{

	@Override
	public void eat() {}

	@Override
	public void sleep() {}
	
}
class demo3 implements interfaceD{//2种实现接口的方法：1.这个类实现接口重写接口中的方法

	@Override
	public void eat() {
		System.out.println("吃的炒米饭111");
		
	}

	@Override
	public void sleep() {
		System.out.println("睡的香香的11！！！");
		
	}
	
}
class demo4 implements interfaceA{
	@Override
	public void show() {
		System.out.println("这是一个实现接口A的方法");		
	}
	@Override
	public void sing() {
		System.out.println("唱国歌");
	}	
}

接口的多态表现形式

package part1.接口;
//接口的出现 一定程度上对我们的代码设计进行了解耦
//耦合性-两只之间的联系
//第2钟多态形式的表现   实现在了    类实现接口的方法
public class interfaceDemo2 {
    public static void main(String[] args) {
		Computer c = new Computer();
		Keybord k=new Keybord();
		Mouse m = new Mouse();
		c.select(k);
		c.select(m);
	}
}

class Computer{
	public void select(USB device){
		device.dosomething();
	}
}

interface USB{
	public abstract void dosomething();
}

class Keybord implements USB{
	@Override
	public void dosomething() {	
		System.out.println("数据输入完成了！！！");
	}
	
}

class Mouse implements USB{
	@Override
	public void dosomething() {
		System.out.println("坐标输入完成了！！！");
	
	}
	
}

 

 

接口特例----匿名类

实现了代码的传递

package part1.接口;
//实现了代码的传递，匿名类
public class interfaceDemo3 {
	public static void main(String[] args) {
		Button loginbutton = new Button();
		Button registerbutton = new Button();
		loginbutton.dosomething(
				/*
				 * new |Loginbutton()省略部分
				 * class Loginbutton implements| Mission()
				 * */
				new Mission() {	
					@Override
					public void dotask() {		
						System.out.println("完成了提交按钮功能...");
					};
				}
				);
		registerbutton.dosomething(new Mission() {	
			@Override
			public void dotask() {
				System.out.println("完成了注册功能...");
				
			};
		 }
				);
	}

}

interface Mission{
	void dotask();
}

class Button{
	public void dosomething(Mission mission){
		mission.dotask();
	}
}

内部类

就是当我们在描述一个事物的时候，发现该事物当中又存在另外一个事物的时候
我们把当前的事物称之为外部类 另一个事物称之为内部类

 

区分内部类成员和外部类成员

           Outter.this.xxx       this.xxx

调用内部类的静态成员

            内部类在一个类中定义，间接相当于一个类的成员变量，而成员变量在创建对象时才会存在。则如若在内部类中定义了静态的成员函数那么此时的内部类也应该定义为静态的。这样才不会和静态的特点(静态成员是优先于对象存在的)发生冲突。  否则会自相矛盾，发生报错。(假若不是静态型内部类)你定义了内部类的静态成员，此时内部类为非静态只有外面类创建对象之后内部类才能调用，而静态肯定是在创建对象之前就已经存在了。这很矛盾。。

package part02.内部类;

public class InnerClassDemo {
	public static void main(String[] args) {
		/*1.如何调用内部类的成员
		 想要调用内部类的成员 必须先创建内部类的对象 new Inner()
		 但是直接new Inner()发现找不到Innner这个类
		 因为Inner是Outter的非静态成员
		 所以Inner这个类想要存在的前提是创建Outter对象 new Outter()
		Outter.Inner inner=new Outter().new Inner();
		System.out.println(inner.num);
		inner.show();
		 */
		
		/*
		 2.如何区分内部类成员和外部类成员
		 System.out.println(Outter.this.num+":"+this.num); 
		 */
		
		/*
		 3.如何调用内部类的静态成员
		 静态的东西是优先于对象加载进方法区的 
		 然而haha在一个非静态的类当中，必须先创建Inner对象的haha才存在
		 这就与我们的第一点冲突了
		 怎么处理？
		 如果内部类中有静态 那么内部类必须是静态的
		 	此时就产生一个问题了，内部类当中无法访问外部类的非静态
		 	但是可以访问内部类中的非静态
		 */
		System.out.println(Outter.Inner.haha);
	}
}
class Outter{
	
	int num=10;
	
	int num1=30;
	
	//非静态
	static class Inner{
		int num=20;
		int num2=40;
		//静态
		static int haha=100;
		public void show(){
			System.out.println("Inner show......");
			//Outter.(这个类的)this.(的对象)num(的num)
//			System.out.println(Outter.this.num+":"+this.num);
			//Cannot make a static reference to the non-static field num1
//			System.out.println(num1+":"+num2);
		}
	}
}