继承与多态

继承:类和类之间的关系
* 在Java所有类都默认继承自Object
* class child extends Parent extends关键字实现类的继承
* 单根性:一个类只能存在一个父类
* 在Java中的继承:子类可以继承父类的任何非私有成员(变量方法构造) 子类永远比父类拥有更多的成员子>父
* 提升代码的复用性:
* 减少代码的冗余

子类继承父类public和protected修饰的属性和方法，不能继承private成员和构造方法。

子类访问父类成员构造方法：

①使用super关键字，super代表父类对象

②在子类构造方法中，调用且必须是第一句

③不可以访问父类中定义为private的属性和方法

访问构造方法：

super();

super(name);

访问父类属性：

super.name;

访问父类方法：

super.print();

注：super和this的区别，this指当前对象，super指父类对象，super一般只存在于有继承关系的类中。

抽象类: abstract关键字修饰的类
* 不能直接实例化
* 内部可以存在抽象方法:

1 抽象类和抽象方法使用abstract关键字修饰

2 抽象方法不能存在方法体，可以设置返回类型

3 抽象类中的抽象方法子类必须重写，除非子类也是抽象类

4 抽象类中既能存在抽象方法，又能存在非抽象方法，也可以构造函数

 1 //抽象类
 2 public abstract class Clothes {
 3     String quality;//衣服材质
 4     
 5     //普通方法
 6     public void cross(){
 7         System.out.print("衣服都可以穿！");
 8     }
 9     //抽象方法
10     public abstract void type();//衣服类型
11     
12     //构造方法
13     public void Clothes(){
14         
15     }
16     public void Clothes(String s){
17         
18     }
19 
20 }

1 public class Skirt extends Clothes{
2 
3     //抽象方法子类中必须重写
4     @Override
5     public void type() {
6         System.out.print("我是一件裙子！");
7         
8     }

* 类型转换: 向上转型: 子类向父类转换自动转换
* 向下转型: 父类向子类转换强制 ClassCastException instanceof （在调用子类特有的成员时）

 1 public class Test {
 2     public static void main(String[] args){        
 3         Clothes c=new Skirt();
 4         Clothes c1=new Clothes();
 5         Skirt s=new Skirt();
 6         if(c1 instanceof Skirt){
 7             //父类向子类转换时，会抛出classcastException异常
 8              s=(Skirt) c1;            
 9         }else{
10             s.price();
11         }
12         //子类向父类转换时，会自动转换
13         c1=s;
14         c.type();        
15     }    
16 }

* 子类可以再任何时刻替代父类: is a关系

多态：同一引用类型，使用不同的实例而执行不同操作

①方法的重写是实现多态的基础。

1 public  class Clothes {
2     String quality;//布料
3         
4     public void type(){
5         System.out.print("我是衣服！");
6     }

1 public class Skirt extends Clothes{    
2     String pinp;//品牌
3     //重写父类方法
4     @Override
5     public void type() {
6         System.out.println("我是一件裙子！");        
7     }

②使用父类作为方法的形参，是Java中实现和使用多态的主要方式。

创建父类方法

 1 public  class Clothes {
 2     String quality;//布料
 3         
 4     public void type(){
 5         System.out.print("我是衣服！");
 6     }
 7     
 8     //制作方式
 9     public void made(){};
10 }

创建两个子类

 1 public class Skirt extends Clothes{    
 2     String pinp;//品牌
 3     
 4     @Override
 5     public void type() {
 6         System.out.println("我是一件裙子！");        
 7     }    
 8     //重写父类方法
 9     public void made(){
10         System.out.print("我是裙子，由工厂制作出来的！");
11     }
12 
13 }

1 public class TShirt extends Clothes{
2     
3     //重写父类方法
4     public void made(){
5         System.out.print("我是T恤，由私人定制的！");
6     }
7 
8 }

创建形参是父类的方法

1 public class Service {
2     
3     //创建父类形参方法
4     public void made(Clothes cs){
5         cs.made();
6     }
7 
8 }

创建测试类

 1 public class TestCase {
 2         
 3     public static void main(String[] args){
 4         //创建Service对象
 5         Service se=new Service();    
 6         //通过父类将对象指向子类
 7         Clothes t=new TShirt();
 8         //调用方法
 9         se.made(t);
10     }
11 
12 }

输出结果：

③使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式。

 1 //父类作为方法的返回值
 2     public Clothes getID(int num){
 3         Clothes cl=null;
 4         if(num==1){
 5             cl=new Skirt();
 6             cl.made();
 7         }
 8         else if(num==2){
 9             cl=new TShirt();
10             cl.made();
11         }
12         return cl;
13         
14     }

方法调用及运行结果：