黑马程序员-面向对象-接口和多态-优快云博客

---------------------- android培训、java培训、期待与您交流！ ----------------------

接口和多态

接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract

记住：接口中的成员都是public的。而且，如果这些修饰符如果缺少，jvm会进行自动添加。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现，中间用逗号分割。也可以在继承一个类的同时实现多个接口。

接口中的常量都是静态的，可以静态调用，也可以通过接口名调用。

接口的特点：

1.接口是对外暴漏的规则

2.接口是程序的扩展

3.接口可以多实现

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5.接口与接口之间可以有继承关系。都没有方法体甚至可以多继承。

接口与抽象类共性：都是不断抽取出来的抽象的概念

接口与抽象类区别：

区别 1：抽象类体现继承关系，一个类只能单继承,接口体现实现关系，一个类可以多实现

区别 2：抽象类是继承，是 "is a "关系,接口是实现，是 "like a"关系

区别 3：抽象类中可以定义非抽象方法，供子类直接使用,接口的方法都是抽象，接口中的成员都有固定修饰符

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}

interface InterA
{
	public abstract void show();
}

class Demo
{
	public void function(){}
}
//接口可以多实现，中间用逗号分割。也可以在继承一个类的同时实现多个接口。
class Test extends Demo implements Inter,InterA
{
	public void show(){}
}


interface A
{
	void methodA();
}
interface B //extends A
{
	void methodB();
}

interface C extends B,A//接口之间可以多继承
{
	void methodC();
}

class D implements C
{
	public void methodA(){}
	public void methodC(){}
	public void methodB(){}
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		System.out.println(t.NUM);//接口中的常量都是静态的，可以静态调用，也可以通过接口名调用。
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);

	}
}

1.多态：某一类事物的多种体现形态。

2.体现：父类或者接口的引用指向或者接收自己的子类对象。

3.作用：多台的存在提高了程序的扩展性和后期可维护性。

4.前提：需要存在继承或者实现关系。

要有覆盖操作。

4，多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

多台的特点：

非静态成员函数：编译时：要查看引用变量所属的类中是否有所调用的成员方法，有通过，没有则失败。

在运行时：要查看对象所属的类中是否有所调用的成员方法。

简单总结就是：成员函数的多台调用时，编译时期看左边，运行时期看右边。

成员变量：子父类中有重名变量，只看引用变量所属的类。即无论编译和运行都是参考左边。

在多台汇中静态成员函数的特点：无论编译和运行都看左边。

向上转型：向上类型转换可以是自动转换的

向下转型：向下类型转换必须强制类型转化

千万不要出现这样的操作，就是将父类对象转成子类类型。

我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

多态自始至终都是子类对象在做着变化。

关键字 instanceof：用于判断所属类型

		if(a instanceof Cat)//判断a是否是cat类型
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}

需求：数据库的操作。

数据是：用户信息。

1，连接数据库。JDBC Hibernate

2，操作数据库。

c- create r- read u- update d- delete

3，关闭数据库连接。

interface UserInfoDao
{
	public void add(User user);

	public void delete(User user);
}

class UserInfoByJDBC implements UserInofDao
{

	public void add(User user)
	{
		1,JDBC连接数据库。;
		2，使用sql添加语句添加数据。;
		3，关闭连接。
	}
	public void delete(User user)
	{
		1,JDBC连接数据库。;
		2，使用sql添加语句删除数据。;
		3，关闭连接。
	}
}

class UserInfoByHibernate implements UserInfoDao
{
	public void add(User user)
	{
		1,Hibernate连接数据库。;
		2，使用sql添加语句添加数据。;
		3，关闭连接。
	}
	public void delete(User user)
	{
		1,Hibernate连接数据库。;
		2，使用sql添加语句删除数据。;
		3，关闭连接。
	}
}

class  DBOperate
{
	public static void main(String[] args) 
	{
		//UserInfoByJDBC ui = new UserInfoByJDBC();
//		UserInfoByHibernate ui = new UserInfoByHibernate();
		UserInfoDao ui = new UserInfoByHibernate();
		ui.add(user);
		ui.delete(user);
	}
}

Object类

是所有对象的直接或者间接超类。该类中定义了所有类都具备的功能。

Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。

只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。

覆盖父类中的equals方法，使用多台的方式接收参数，内部需要向下转型

class Demo extends Object
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	
	public boolean equals(Object obj)//Object obj = new Demo();
	{
		//判断类型
		if(!(obj instanceof Demo))
			return false;
		Demo d = (Demo)obj;//向下转型

		return this.num == d.num;
	}
	
	public String toString()
	{
		return "demo:"+num;
	}


}

内部类：

内部类的访问规则：

1，内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this

2，外部类要访问内部类，必须建立内部类对象。

class Outer
{
	private int x = 3;

	
	class Inner//内部类
	{
		//int x = 4;
		void function()
		{
			//int x = 6;
			System.out.println("innner :"+Outer.this.x);
		}
	}

	/**/
	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}


class  InnerClassDemo
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method();

		//直接访问内部类中的成员。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
	}
}

内部类可以被私有。。

访问格式：

1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类对象。

格式
	外部类名.内部类名  变量名 = 外部类对象.内部类对象;
	Outer.Inner in = new Outer().new Inner();

2,当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

static:内部类就具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？

uter.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事务在使用外部事物的内容。

内部类定义在局部时，

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

匿名内部类:

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：

内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

class Outer
{
	int x = 3;

	
	class Inner extends AbsDemo
	{
		int num = 90;
		void show()
		{
			System.out.println("show :"+num);
		}
		void abc()
		{
			System.out.println("hehe");
		}
	}
	

	public void function()
	{
		//AbsDemo a = new Inner();
		Inner in = new Inner();
		in.show();
		in.abc();
	

		AbsDemo d = new AbsDemo()//
		{
			int num = 9;
			void show()
			{
				System.out.println("num==="+num);
			}
			void abc()
			{
				System.out.println("haha");
			}
		};

		d.show();
		//d.abc();//编译失败;

	}
}

如果一个类没有明确的父类，可以使用Object创建匿名子类并写一个方法和调用方法

不可以给类起名字使用类名调用，因为object中没有那个方法。

class InnerTest
{

	public static void main(String[] args)
	{
		new Object()
		{
			public void function()
			{
				Systen.out.println(function);
			}
			
		}.function();


	}
}

---------------------- android培训、java培训、期待与您交流！ ----------------------