继承、多态

  

   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	继承:
     
    
   

    

     

    
    

     

      		面向对象的三大特征之一:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		是类和类之间的一种拓展关系,是一种从一般到特殊的关系;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		格式: sub   extends Super,  我们把sub称为子类或者拓展类, 把super称为父类或者基类(超类)
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	泛化:	把子类中的共性抽取到父类的过程;
     
    
   

    

     

    
    

     

      	特化:	子类在父类的基础之上,拓展自己特有的状态和特征;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		Object:	是所有类的直接父类后间接父类;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class  Student{} 等价于  class  Student extends Object{}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		直接父类:  直接继承的父类,有且只有一个,也就是说Java只支持单继承;
     
    
   

    

     

    
    

     

      		间接父类:	直接父类或间接的父类的父类;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	方法和字段:
     
    
   

    

     

    
    

     
		private 修饰的成员不能被继承;
     
    
   

    

     

    
    

     

      		默认访问权限的成员能不能被继承?  要是在同一个包中就能被继承
     
    
   

    

     

    
    

     
		protected 修饰的成员,可以被继承;
     
    
   

    

     

    
    

     
		public 修饰的成员,可以被继承;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		构造方法能不能被继承? 不能
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class Person{
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			public Person(){}
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class Student extends Person
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			//public Person(){}//ERROR
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		若父类所有的构造方法是用 private 修饰,不能有子类;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	子类实例化:
     
    
   

    

     

    
    

     

      		子类初始化,会先默认调用父类的一个无参的构造方法,自己再初始化;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		子类的构造方法里,有一个隐式的 super();
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		若我们显示的让子类去调用父类有参数的构造方法,默认的隐式的构造方法就不会被调用了;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		子类对象创建之前,必须有一个父类对象;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	方法覆写:
     
    
   

    

     

    
    

     

      			当父类的某一个方法不适合子类对象的时候,就应当重新修改方法体;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		遵循的原则:  一同 两小 一大:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		一同: 方法签名相同
     
    
   

    

     

    
    

     

      		两小:  
     
    
   

    

     

    
    

     
			1.返回值类型可以是父类返回值类型的子类或相同;
     
    
   

    

     

    
    

     

      				父类的:Object show(){
     
    
   

    

     

    
    

     
					return null;
     
    
   

    

     

    
    

     

      				}
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				子类的:  String show()
     
    
   

    

     

    
    

     

      				{
     
    
   

    

     

    
    

     
					return null;
     
    
   

    

     

    
    

     

      				}
     
    
   

    

     

    
    

     
			2.异常更小
     
    
   

    

     

    
    

     

      		一大: 子类方法的访问权限 >= 父类方法的访问权限
     
    
   

    

     

    
    

     

      				父类的: private Object show(){
     
    
   

    

     

    
    

     
					return null;
     
    
   

    

     

    
    

     

      				}
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				子类的:  String show()
     
    
   

    

     

    
    

     

      				{
     
    
   

    

     

    
    

     
					return null;
     
    
   

    

     

    
    

     

      				}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      			上面这个不是覆写:因为私有成员不能被继承
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	必杀技:  若子类方法是覆写方法的话,  那么在方法上加上 @Override  是可以编译通过的;
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		静态方法能不能被覆写:	不能!
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			方法的覆写:属于多态,而多态是基于对象的(父类的一个变量指向子类的一个对象);
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			而静态方法不属于对象,属于类;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     
	super:
     
    
   

    

     

    
    

     

      		用在子类.,
     
    
   

    

     

    
    

     
		super:表示父类对象
     
    
   

    

     

    
    

     

      		用于调用父类的方法或字段,用法和this一模一样
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		调用父类的构造方法:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		super(参数);和this(参数);
     
    
   

    

     

    
    

     

      		都表示在构造方法里调用构造方法;都必须写在构造方法的第一行
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		不同:  this(参数),调用的当前类里面的构造方法,super(参数),调用的是直接父类里构造方法
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	多态:
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      		面向对象的三大特征之一:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		Person  p = new Student();
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		p的真正类型是学生;当是我们只把他当一般人看待;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		编译类型: 申明变量的类型  Person	,  是我们把它当做什么
     
    
   

    

     

    
    

     

      		运行类型: 创建对象的类型  Student	,  是对象真正的类型
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		多态的产生前提:继承
     
    
   

    

     

    
    

     

      		当编译类型和运行类型不一致的时候,就会产生多态;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		多态定义:  同一个实体有多种形态;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		多态的作用:	可以屏蔽不同子类对象之间的差异,从而能写出更加通用的代码,能提高效率,维护性;
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      	引用类型转换:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		向上转型:  小->大, 自动转换, 这里说的小和大,说的是 继承关系中的子类和父类.
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      			可以把子类对象赋给父类变量;
     
    
   

    

     

    
    

     
			Person  p = new Student();
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			Object类是所有类的父类.那么Object类型的变量能不能接受一切值? 可以!
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		向下转型:	大 -> 小
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      			父类对象强制转换成子类对象;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			Student  s = (Student)p;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			一般的,再强转之前,要先判断该对象时候属于这个类类型;
     
    
   

    

     

    
    

     
				boolean b = 对象 instanceof 类
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      				对象的类型和类必须有继承关系;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			先判断 p是否是学生类型:  
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			if(p instanceof Student)
     
    
   

    

     

    
    

     

      			{
     
    
   

    

     

    
    

     
				Student  s = (Student)p;
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      	多态方法调用:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class Car{
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			public void run(){}
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		class Binli extends Car
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			public void paoMM(){
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			public void run(){}
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		Car c  = new Binli();
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		1.调用的方法不是覆写方法,子类有,父类没有;
     
    
   

    

     

    
    

     

      			c.paoMM();//找不到方法,编译的时候,去Car类里去找;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			if(c instanceof Binli)
     
    
   

    

     

    
    

     

      			{
     
    
   

    

     

    
    

     
				Binli b =(Binli)c;
     
    
   

    

     

    
    

     

      				b.paoMM();
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
		2.调用的方法是覆写的方法,父类有,子类也有;
     
    
   

    

     

    
    

     

      			c.run();//调用的是子类的方法,,在编译的时候去Car里找run方法,但运行期间找的Binli类里的run方法;
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	组合:
     
    
   

    

     

    
    

     

      		 extends  继承是一种从一般到特殊的关系,  也就是说 子类是父类的一种特殊情况;
     
    
   

    

     

    
    

     
		 
     
    
   

    

     

    
    

     

      			子类 is  父类的一种  is  A 关系
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		组合,包含:  比如手机和手机卡,  手机里有手机卡 ,has  A关系
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		圆心和圆的关系:
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		练习:判断一个点和圆的关系(外,内,上);
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		// 描述一个点,只需要坐标就ＯＫ了
     
    
   

    

     

    
    

     
		class Dot
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			private double x;//横坐标
     
    
   

    

     

    
    

     
			private double y;//纵坐标
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
			//根据坐标来创建点
     
    
   

    

     

    
    

     
			public Dot(double x, double y)
     
    
   

    

     

    
    

     

      			{
     
    
   

    

     

    
    

     
				this.x  =x;
     
    
   

    

     

    
    

     
				this.y  = y;
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			//getter setter
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		/*
     
    
   

    

     

    
    

     

       描述一个圆, 
     
    
   

    

     

    
    

     

       
     
    
   

    

     

    
    

     

       圆包含圆心,圆心又是一个点
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
		class Circle{
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
			private Dot o;//圆心//等价于private Dot o = null;
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			//private Dot p;/不能这样设计,这样就已经表示圆包含需要判断的点了
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			private  double r;//半径
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			//根据半径和圆心来创建指定的圆
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			public Cirlce(Dot o, double r)
     
    
   

    

     

    
    

     

      			{
     
    
   

    

     

    
    

     
				//this.o.setX(o.getX());ERROR
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				this.o = o;
     
    
   

    

     

    
    

     
				this.r  = r;
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			//写一个判断点和圆的关系的方法
     
    
   

    

     

    
    

     
			public String judge(Dot p)
     
    
   

    

     

    
    

     

      			{
     
    
   

    

     

    
    

     
				double x = o.getX() - p.getX();
     
    
   

    

     

    
    

     
				double y = o.getY() - p.getY();
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				double xx = x * x;
     
    
   

    

     

    
    

     
				double yy = y * y;
     
    
   

    

     

    
    

     
				double rr = r * r;
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				if(xx + yy  - rr > 0)
     
    
   

    

     

    
    

     

      				{
     
    
   

    

     

    
    

     
					//圆外
     
    
   

    

     

    
    

     

      				}else if(xx + yy - rr == 0)
     
    
   

    

     

    
    

     

      				{
     
    
   

    

     

    
    

     
					//圆上
     
    
   

    

     

    
    

     

      				}else{
     
    
   

    

     

    
    

     
					//圆内
     
    
   

    

     

    
    

     

      				}
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     
				return "";
     
    
   

    

     

    
    

     
				
     
    
   

    

     

    
    

     

      			}
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			/*
     
    
   

    

     

    
    

     

       getter/setter
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     

      		....main...
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			//创建圆心点
     
    
   

    

     

    
    

     
			Dot o = new Dot(0.0,0.0);
     
    
   

    

     

    
    

     
			//创建指定大小的圆
     
    
   

    

     

    
    

     
			Circle c = new Circle(o, 5);
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			//还需要一个判断的点
     
    
   

    

     

    
    

     
			Dot p = new Dot(3,4);
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			//判断
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     
			String ret =c.judge(p);
     
    
   

    

     

    
    

     
			
     
    
   

    

     

    
    

     

      			System.out.println(ret);
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     
		
     
    
  
 

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/81567099