继承:

可以让一个类继承另一个类的属性和方法.

继承的使用:

先创建一个父类,在父类中定义一些属性和方法.

package com.MyLol;

public class Army {

    //打击敌人
    public String beat(){
        return null;
    }
    //保家卫国
    public void defend(){
        System.out.println(beat());
    }
}

在创建一个子类用extends关键字继承父类的属性和方法.

package com.MyLol;

public class Airforce extends Army{
      @Override
    public String beat(){
        return "我是空军，我要用导弹打击敌人";
    }
}



package com.MyLol;

public class LandArmy extends Army{
    @Override
    public String beat(){
        return "我是陆军, 我用坦克打击敌人";
    }
}




package com.MyLol;

public class Navy extends Army{
    @Override
    public String beat() {
        return "我是海军，我要用鱼雷打击敌人";
    }
}

创建一个测试类,使用子类创建一个对象,就可以获取父类的属性和方法了

package com.Test001;
import com.MyLol.Airforce;
import com.MyLol.Army;
import com.MyLol.LandArmy;
import com.MyLol.Navy;

public class Test002 {
    public static void main(String[] args) {
        Army n = new Navy();
        n.defend();
        Army a = new Airforce();
        a.defend();
        Army l = new LandArmy();
        l.defend();
    }
}

子类继承父类的时候默认继承无参的构造方法

方法的重写

在子类中对父类的方法进行重写

可以让不同的子类具有不同的特性

在java中所有的类都有一个父类,叫Object.

public class MyCommon extends Object{


}

常见的两种重写方法.

通过重写toString()方法,将对象属性转换成字符串然后进行输出

 @Override
    public String toString() {
        return "MyCommon{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

通过重写equals(Object obj),实现判断相等的功能

    @Override
    public boolean equals(Object o) {
        MyCommon common = (MyCommon) o;
        if(this.name.equals(common.getName())){
            if(this.age == common.getAge()){
                return true;
            }
        }
        return false;
    }

Super

super就是指向父类对象的引用

两个作用

作用一:可以调用父类的属性和方法

    @Override
    public int getMoney() {
        return 0;
    }

    public void checkMoney(){
        System.out.println("余额:"+super.getMoney());
    }

作用二:可以调用父类的构造方法

每个类中都有一个默认的无参构造方法,当无参的构造方法被重载后,默认的无参构造方法就会失效.

一个子类继承父类的时候,在使用子类创建对象的时候,必须调用父类的构造方法,(一般默认情况是调用父类的无参构造方法).

一但父类的构造方法被草重载后,父类默认的无参构造方法就会失效,那么子类默认情况下就调用不到父类的无参的构造方法.

解决方法:

方法一:给父类重新添加一个无参的构造方法

方法二:在子类中使用super调用父类有参的构造方法

    public MySon(int money){
        super(10);
        System.out.println("子类的构造方法");
    }

封装:

概念

在编程中要求高内聚,低耦合,某个B对象调用A对象的时候,B对象不需要了解A对象的细节

(

高内聚概念:一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。

低耦合概念:一个完整的系统，模块与模块之间，尽可能的使其独立存在。即，让每个模块，尽可能的独立完成某个特定的子功能。模块与模块之间的接口，尽量的少而简单

。)

在面向对象设计中,主要通过封装来对对象的一些具体细节进行屏蔽;

封装类;

主要针对的就是属性,构造方法和一般方法

封装的两个过程:

主要是通过修饰符来调整属性,方法的可见性

对于需要操作的属性或方法,我们可以通过封装其他的开发方法进行暴露

两个属性重要的封装方法:

getter:通过对属性的封装,获得属性的具体值.

返回类型必须是被封装属性的类型

必须使用小写的get开头

属性名称在get之后首字母要大写

    private int money;

    public int getMoney() {
        return money;
    }

setter:通过对属性的封装,来修改属性的具体值

输入的参数类型,要和封装的参数类型一致,没有返回值

必须是小写的set开头

属性名称在set之后,而且首字母需要大写

在方法内部进行修改

方法不需要强制进行封装,主要是根据业务需求来定

常用的修饰符:

public:公共的

private:私有的

protected:受保护的

默认的(这个不用写)

多态:

概念:

多态是建立在继承的基础上,父类引用指向子类对象,从而产生多种形态

父类引用仅能调用父类声明的属性和方法,子类特有的属性和方法不能调用

如果子类重写了父类的方法,那么通过父类调用子类的时候,不同的子类就有不同的调用方法.

拆箱和装箱:

向上转型是装箱,使用父类指向子类对象,叫做装箱.

Father f1 = new Hero();  //Father是hero的父类

向下转型是拆箱,将父类强转成子类的类型,必须要拆箱之后才可以使用父类没有的属性和方法.

 Hero h1 = (Hero) f1;   //hero是f1的子类
 h1.skill();//调用hero的skill

拆箱和装箱不会对new出来的对象有任何影响.

在拆箱的时候如果类型不匹配的话,就会报错.

instance of:

可以判断一个对象的类型

对象 instance of 类型  //返回一个boolean类型

基本案例:

    if(all[i] instanceof Hero){
    	//发动一次英雄技能攻击
    	//对其进行拆箱
    	//Hero hero1 = (Hero) all[i];
    	//hero1.skill(all[index]);
    	((Hero)all[i]).skill(all[index]);
    }