继承|抽象类|接口

继承:

为了提高代码的复用性 延续+扩展
父类:子类的共性
子类就可以使用父类中的成员

多态:在继承的基础之上及方法的重写,父类引用指向子类类型的对象,这就是多态的表现形式
父类引用只能使用父类中有的成员,子类独有的内容无法使用,但是可以通过向下转型来操作
可以提高代码的复用性,灵活性,扩展性,便于后期维护

转型 cast

   		孔子装爹案例:	
	  		class 孔子爹{void teach(){做生意...}}
	  		class 孔子    {void teach(){论语...} void play(){玩荣耀...}}
	  		一天一个人来请孔子爹去授课,孔子爹外出了,孔子化化妆装成孔子爹样子去授课
  
  		向上转型----化妆
  			孔子爹  k=new 孔子();
  			k.teach();  //讲的是论语  调用的是子类中重写的方法
  
  		孔子和学生们玩的很好,相约一起打游戏
  		
  		 向下转型 : 为了使用子类独有的内容 ---卸妆
 			小范围类型 变量 = (小范围类型)大范围类型的数据;  //父类->大范围   子类->小范围
  			long l=100;
  			int i=(int)l;
  
  			孔子  kk=(孔子)k;
  			kk.play();

向下转型可能会遇到异常:ClassCastException 类型转换异常
为了避免这个异常的出现,instanceof
引用 instanceof 类型 判断前面的引用是否是后面类型的对象|子类对象,如果是返回true,如果不是返回false

public class CastDemo01 {
	public static void main(String[] args) {
		//向上转型
		KongZiDie k=new KongZi();
		k.teach();
		//向下转型  ClassCastException 类型转换异常
		if(k instanceof Brother){
			Brother kk=(Brother)k;
			kk.play();
		}else{
			KongZi kk=(KongZi)k;
			kk.play();
		}
	}	
	//任意类型的参数都可以传进来
	static void test(Object str){
		System.out.println(str);
	}
}

class KongZiDie{
	String name="孔子爹";
	void teach(){
		System.out.println("做生意...");
	}
}
//孔子
class KongZi extends KongZiDie{
	String name="孔子";
	void teach(){
		System.out.println("论语...");
	}
	
	void play(){
		System.out.println("玩游戏...");
	}
}
//孔子兄弟
class Brother extends KongZiDie{
	String name="兄弟";
	
	void play(){
		System.out.println("英雄联盟...");
	}
}

抽象类

抽象类:被abstract修饰的类就是抽象类
抽象方法: 方法有,不知道如何定义方法体,那就不定义
被abstract修饰的方法为抽象方法
抽象方法没有方法体
抽象方法必须存在与抽象类中

案例:公司开发部 java开发工程师 web开发
java开发工程师 work: 服务端开发
web开发 work: 网页端开发
根据子类的共性,提取出父类,work() Develop 开发部

注意:
抽象类不能实例化
抽象方法必须存在与抽象类中
抽象类可以有抽象方法,也可以存在具体的方法
抽象方法一定需要被重写的
抽象类的使用:
具体的子类: 必须重写所有的抽象方法+按需新增
抽象的子类: 按需重写抽象方法+按需新增
抽象方法被重写过一次,就可以不被重写了
abstract不能和static,final,private,native不能一起使用

public abstract class Develop extends Object{
	//抽象方法
	public abstract void work();
	
	//具体方法
	public void haha(){
		System.out.println("你快乐嘛~");
	}
}

/*
 * 具体子类
 */
public class UI extends Web{

	@Override
	public void work() {
		System.out.println("开开心心做设计...");
	}
	
	void smile(){
		System.out.println("聊天止于微笑");
	}

}

//抽象子类
public abstract class Web extends Develop{
	//抽象方法不知如何定义方法体,那就不定义
	
	//新增方法
	public void hehe(){
		System.out.println("聊天止于呵呵...");
	}
}

//具体子类:所有的方法都有方法体
public class JAVA extends Develop{

	@Override
	public void work() {
		System.out.println("每天都在写bug找bug");
	}

	//新增功能
	public void sleep(){
		System.out.println("变教课变睡觉...");
	}
}

接口: ***

接口理解为一个特殊的抽象类
就是功能点的集合

接口的优点:
1.避免单继承的局限性
2.解耦
3.提高代码的复用性
4.定义开发规范

定义接口:
使用一个interface定义接口

组成:
jdk1.7及之前版本的要求:
	1.公共的静态的常量  public static final 数据类型  变量名 = 值;
		默认修饰符为public static final,修饰符可以选择性的省略
		可以通过接口名字使用
		2.公共的抽象的方法  public abstract 返回值类型 方法名();
			默认修饰符为public abstract,,修饰符可以选择性的省略

注意:
1.接口不能实例化
2.抽象必须重写
3.接口的使用:
1)具体的实现类: 实现的接口中的所有抽象方法 + 按需新增
2)抽象实现类 : 实现部分抽象方法,按需新增
4.类只能单继承类,但是可以多实现接口,使用implements关键字进行实现,多个接口之间使用,分隔
5. 类和类之间只能单继承
类和接口之间只能类实现接口,可以多实现
接口和接口之间,只能继承,但是可以多继承
6.类要后继承后实现

public class InterfaceDemo01 {
	public static void main(String[] args) {
		//System.out.println(Fly.A);
		//Fly.A=20;
		
		NiHao nihao=new NiHao();
		NiHao.up();
		NiHao.down();
		NiHao.haha();
		NiHao.code();
	}
}

//具体实现类

class NiHao implements A{

	@Override
	public void up() {
		System.out.println("张开翅膀就飞起来的");
	}

	@Override
	public void down() {
		System.out.println("砍掉翅膀就掉下来了");
		
	}

	@Override
	public void haha() {
		System.out.println(" hahhahaha");
	}

	@Override
	public void hehe() {
		System.out.println("heheheh");
	}

	@Override
	public void heihei() {
		System.out.println("嘿嘿笑");
	}

	@Override
	public void xixi() {
		System.out.println("xixixixi");
	}
	
	//新增功能
	public void code(){
		System.out.println("aaaaaa");
	}
	
}


interface Fly{
	void up();  //起飞
	void down();  //降落
}

interface Smile{
	 //int  A = 10;
	 //公共的抽象的方法
	 public abstract void haha();
	 void hehe();
	 void heihei();
	 void xixi();
}

//接口继承接口
interface A extends Fly,Smile{}