java笔记-----抽象类、接口、多态

抽象类

抽象类的基本概念

声明一个抽象类

public abstract class Women{

private String name;

public abstract void say();//抽象方法

}

/**
	abstract抽象类
	抽象类规则：
	1、抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
	2、非抽象类继承抽象类必须实现所有抽象
	3、抽象类可以有方法实现和属性
	4、抽象类不能被实例化
	5、抽象类不能声明为final

*/
class AbstractDemo
{
	public static void main(String[] args) 
	{
		Meinv m = new Meinv();
		m.setName("刘亦菲");
		m.say();
		Chounv c = new Chounv();
		c.setName("凤姐");
		c.say();
	}
}
/**
	abstract声明一个类是抽象类
	女人
*/
abstract class Women
{
	private String name;
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public abstract void say();//抽象方法，只有声明，没有实现
}

class Meinv extends Women
{
	public void say()
	{
		System.out.println("我是美女，我的名字是:"+getName());
	}
}
class Chounv extends Women
{
	public void say()
	{
		System.out.println("我是丑女，我的名字是:"+getName());
	}
}

接口的概念

接口的定义

1、接口修饰符和类的修饰符是一样的

2、interface是定义接口的关键字

3、接口里的成员变量默认为public static final 类型的

4、接口不能声明为final的，因为final类型的必须要实现

/**
	接口

*/
class InterfaceDemo
{
	public static void main(String[] args) 
	{
		Goddess g = new Goddess();
		g.cry();
		Girl g1 = new Girl();
		g1.cry();
	}
}
//定义一个接口
interface Hit
{
	public void cry();//抽象方法
}
//定义个女神类，实现接口对接
class Goddess implements Hit//interface用implements去连接接口
{
	public void cry()
	{
		System.out.println("我是女神");
	}
}
class Girl implements Hit
{
	public void cry()
	{
		System.out.println("我是女汉子");
	}
}

接口的使用规则：

1、接口可以继承多个接口

2、一个类可以实现多个接口

3、抽象类实现接口可以不实现方法

4、接口中的所有方法的访问权限都是public

5、接口中定义的属性都是常量

/**
	接口

*/
class InterfaceDemo
{
	public static void main(String[] args) 
	{
		Goddess g = new Goddess();
		g.cry();
		Girl g1 = new Girl();
		g1.cry();
	}
}

interface A
{
}
interface B
{
}
//吃食接口
interface IEat
{
	public void eat();	
}
//定义一个接口
//接口可以继承多个接口
//接口不能被实例化
interface Hit extends A,B
{
	//public static final都可以省略，常量名通常都大写
	public static final String NAME = "小白";//在接口中定义的属性都是常量
	public abstract void cry();//抽象方法public abstract 可以省略，默认就是public
}
//定义个女神类，实现接口对接
//一个类可以实现多个接口，用，隔开
class Goddess implements Hit,IEat//interface用implements去连接接口
{
	public void cry()
	{
		System.out.println("我是女神");
	}
	public void eat()
	{
		System.out.println("女神吃饭");
	}
}
class Girl implements Hit
{
	public void cry()
	{
		System.out.println("我是女汉子");
	}
}
//抽象类实现接口可以不实现方法
abstract class Person implements Hit
{
}

多态性

向上转型

/**
	多态性
	polymorphism(多态)
*/
public class PolymorphismDemo
{
	public static void main(String[] args)
	{
		//父类就是大，子类就是小
		Person man = new Man();//父类的引用指向子类对象
		man.say();//如果Person中没有say方法的话，man是无法去调用它的
		Person women = new Women();
		women.say();
	}
}
abstract class Person
{
	private String name;
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public abstract void say();//抽象方法 
}
class Man extends Person
{
	public void say()
	{
		System.out.println("我是男的，我继承了人这个类");
	}
}
class Women extends Person
{
	public void say()
	{
		System.out.println("我是女人，我继承了人这个类");
	}
}

向下转型

/**
	多态性
	polymorphism(多态)
*/
public class PolymorphismDemo
{
	public static void main(String[] args)
	{
		//父类就是大，子类就是小
		Person man = new Man();//父类的引用指向子类对象
		man.say();//如果Person中没有say方法的话，man是无法去调用它的
		Person women = new Women();
		women.say();

		//强制转换,向下转型
		Man m = (Man)man;
		m.say();
		//java.lang.ClassCastException 类型转换异常
		Man m1 = (Man)women;//没有父子关系的不能强制转换类型

	}
}
abstract class Person
{
	private String name;
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public abstract void say();//抽象方法 
}
class Man extends Person
{
	public void say()
	{
		System.out.println("我是男的，我继承了人这个类");
	}
}
class Women extends Person
{
	public void say()
	{
		System.out.println("我是女人，我继承了人这个类");
	}
}

多态性小结

1、方法的重载与重写就是方法的多态性表现

2、多个子类就是父类中的多种形态

3、父类引用可以指向子类对象，自动转换

4、子类对象指向父类引用需要强制转换（注意：类型不对会报异常）

5、在实际开发中尽量使用父类引用（更利于扩展）；