`
jiao13953900900
  • 浏览: 31971 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

黑马程序员-面向对象-接口和多态

    博客分类:
  • java
阅读更多

 

---------------------- 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培训、期待与您交流! ----------------------

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics