java中的接口与抽象类

Java特点

• 封装：隐藏实现细节，对外提供接口
  体现： 将属性都私有化，对外提供对应的set,get方法来进行访问
  好处： 提高了安全性，提高了易用性，提高了复用性
• 继承：java支持单继承，不支持多继承。
• 多态：父类的引用或者接口的引用指向了子类的对象

抽象类

特点 ：
抽象方法一定定义在抽象类中,abstract来修饰
抽象类不能实例化，不能使用new关键字
只有子类中子类覆盖了所有的抽象方法后，子类就可以创建对象
如果没有覆盖了所有的抽象方法，那么子类仍然是一个抽象类
问题：
1抽象类中有构造函数吗？
有构造函数，抽象类的构造函数虽然不能给抽象类对象实例化，因为抽象类不能创建对象，但是抽象类有子类，它的构造函数可以给子类的对象实例化
2抽象类与一般类的区别：
相同：都是用来描述事物，对其进行属性和行为的描述
不同：抽象类描述事物的信息不具体，一般类描述事物的信息具体
代码的不同：
抽象类中可以定义抽象方法，但是一般类不行
抽象类不可以实例化，一般类可以
3抽象类一定是父类？
是得。必须子类覆盖抽象方法后，才可以实例化，使用这些方法。
抽象类中可以不定义抽象方法
4abstract关键与啥关键字不能共存？
final：不可以存在子类，不可以被继承;private:不支持覆盖;static：类名调用方法

接口与类

相似点：

• 一个接口可以有多个方法。
• 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
• 接口的字节码文件保存在 .class 结尾的文件中。
• 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

区别：

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final变量。
• 接口不是被类继承了，而是要被类实现。 接口支持多继承。

抽象类和接口

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

多态：父类的引用指向子类的对象

前提：
1必须有关系，继承，实现。
2通常有覆盖

//定义了父类，以及2个实现类，父类比较特殊是抽象类
abstract class Animal
{
	abstract void eat();
}
class Dog extends Animal 
{
	void eat()
	{
		System.out.println("吃骨头");
	}
	void loolHome()
	{
		System.out.println("看家");
	}
}
class Cat extends Animal 
{
	void eat()
	{
		System.out.println("吃私聊");
	}
	void haha()
	{
		System.out.println("asdf");
	}
}
//对象a,b,c分别是正常的子类，向上转型，向下转型
//向上转型：只能只用上面的功能，即父类的功能
//向下转型：只能使用下面的功能，即子类的功能。
class DuoTaiDemo
{
	public static void main(String[] args){

		
		//正常的子类的引用指向子类对象
		Dog a = new Dog();
		a.eat();
		a.loolHome();
		method (a);
		//多态:父类的引用指向了子类的对象
		//向上转型：只能使用父类的功能。
		Animal b = new Dog();
		if(!(b instanceof Dog))//来进行判断
		{
			System.out.println("转型错误");
			return ;
		}

		//向下转型
		Dog c = (Dog) b;
		//好处：可以使用子类型的特?y??功能 
		//弊端：面对具体的子类型，向下转型有风险。容易发生转换类型异常。

		c.eat ();
		c.loolHome ();

	}
	public static void method(Animal animal){
		animal.eat ();
	}
}

多态：接口的引用指向子类的对象。

interface USB
{
	/**
	设备的开启与关闭
	*/
	public void open();
	public void close();
}
class NoteBook
{
	public void run()
	{
		System.out.println("notebook run");
	}
	//使得接口的引用指向了子类对象。
	public void useUSB(USB usb)//定义了一个接口类型的引用
	{
		if(usb!=null)
		{
			usb.open();
			usb.close();
		}
	}
}
//该类实现了接口，
class MouseByMyself implements USB
{
	public void open()
	{
		System.out.println("Mouse open");
	}
	public void close()
	{
		System.out.println("Mouse close");
	}
}
class DuoJieKouDemo
{
	public static void main(String[] args)
	{
		NoteBook book = new NoteBook();
		book.run();
		book.useUSB(null);
		book.useUSB(new MouseByMyself ());
	}
}

多态中成员变量和成员方法和静态方法

总结：

时期	成员变量	成员方法	静态方法
编译	调用该成员变量的引用所属类中的成员变量	调用该成员变量的引用所属类中的成员变量	调用该成员变量的引用所属类中的成员变量
运行	调用该成员变量的引用所属类中的成员变量	对象所属的类中有调用的函数	调用该成员变量的引用所属类中的成员变量
秘诀	编译运行看左边	编译看左边，运行看右边	编译运行看左边

/*
多态中成员的调用
1成员变量
当子父类中出现同名成员变量时，
多态调用时，只看调用该成员变量的引用所属类中的成员变量
只看等号左边的东西。
经过向上转型，使用父类的内容
2成员函数
出现一模一样函数时，
多态调用
编译时看的是引用变量所属的类中的方法
运行时看的时对象所属的类中的方法。
编译看左边，运行看右边
成员方法动态绑定在当前对象上
3静态函数
编译和运行只看引用变量所属类中的方法
编译运行看左边，
与类相绑定，与对象没有关系
*/
class Fu
{
	int num = 4;
	void show()
	{
		System.out.println("fu show");
	}
	static void method(){
		System.out.println ("fu static method");
	}
}
class Zi extends Fu
{
	int num = 6;
	void show()
	{
		System.out.println("zi show");
	}
	static void method(){
		System.out.println ("zi static method");
	}
}
class DuoTaiDemo1
{
	public static void main(String[] args)
	{
		//==================成员变量===============
		Fu a = new Fu();
		System.out.println(a.num);// 4
		Zi b = new Zi();
		System.out.println(b.num); //6,相同时看自己的
		Fu c = new Zi();
		System.out.println(c.num); //4，看左边的东西
		//================成员函数==========================
		Fu d = new Fu();
		d.show();
		Zi e = new Zi();
		e.show();
		Fu f = new Zi();
		f.show();
		//================静态函数==========================
		Fu g = new Fu();
		g.method();
		Zi h = new Zi();
		h.method();
		Fu i = new Zi();
		i.method();
	}
}