JAVA面向对象-----继承_java

面向对象之继承：

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。

一：继承的实现：我们先定义一个人类的类，人类的类记录了人类的基本属性。默认这个"人"类为父类。

public class Person {
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 性别 1代表男 0代表女
     */
    private int gender;
    /**
     * 年龄
     */
    private int age;
}

     public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getGander() {
        return gander;
    }

    public void setGander(int gander) {
        this.gander = gander;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
         public Person() {
    }
         public Person(String nickname, int gander, int age) {
        this.nickname = nickname;
        this.gander = gander;
        this.age = age;
    }

那其他类，如Boy子类和Girl子类继承Person父类时，要使用 extends 关键字。

public class Boy extends Person{
}

public class Girl extends Person{

}

二：面向对象之继承的代码实现虽然子类里面什么也没有，但当子类继承父类时，会继承父类的属性和方法。此时我们可以实例化Boy和Girl类，并采用set方法赋值，get方法读取，然后测试验证。

public class PersonTest {
    @Test
    public void test02(){
        Boy person = new Boy();
        person.setNickname("陈浩楠");
        person.setGander(1);
        person.setAge(20);
        System.out.println("姓名 >>>"+person.getNickname());
        System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));
        System.out.println("年龄 >>>"+person.getAge());
    }
    @Test
    public void test03(){
        Girl person = new Girl();
        person.setNickname("韵菡");
        person.setGander(0);
        person.setAge(21);
        System.out.println("姓名 >>>"+person.getNickname());
        System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));
        System.out.println("年龄 >>>"+person.getAge());
    }
}

三：super关键字

Super关键字，可以用来子类调用父类的成员用，它包括调用父类的public、protected修饰的变量方法。
注意事项：

调用父类的方法：super.父类的方法。
同时super也可以调用父类的构造方法，但是父类中构造方法用private修饰时，不能有子类去继承。
子类可以没有构造方法，他会自动调用父类的构造方法。
在子类中可以调用父类的构造方法，super必须放在子类构造方法的首句。

使用Super实现代码继承：

public class Boy extends Person {
    public Boy() {
    }

    public Boy(String nickname, int gender, int age) {
        super(nickname, gender, age);
    }
}

public class Girl extends Person {
    public Girl() {
    }

    public Girl(String nickname, int gender, int age) {
        super(nickname, gender, age);
    }
}

实例化Boy和Girl类，但可以不用set,方法赋值啦，因为在子类继承啦父类的构造方法构造方法里已经有属性（此属性来自父类）啦，但你实例化赋值时，还是把值赋给啦父类，因为属性来自父类。


public class PersonTest {
        @Test
    public void test04(){
        Boy person = new Boy("浩楠",1,20);
        System.out.println("姓名 >>>"+person.getNickname());
        System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));
        System.out.println("年龄 >>>"+person.getAge());
    }
    @Test
    public void test05(){
        Girl person = new Girl("韵菡",0,21);
        System.out.println("姓名 >>>"+person.getNickname());
        System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));
        System.out.println("年龄 >>>"+person.getAge());
    }
}

四：子父类的实例化顺序 (测试中，结果先调用啦父类的构造方法，然后再调用啦子类的构造方法，但这并不代表先实例化啦父类，其实时先实例化啦子类，只不过是实例化父类的过程先结束罢啦)

public class Person{
    /**
    * 昵称
    */
    private String nickname;
    /**
     * 性别 1代表男  0代表女
     */
    private int gander;
    /**
     * 年龄
     */
    private int age;

    public Person() {
        System.out.println("我是Person类的无参构造方法");
    }

    public Person(String nickname, int gander, int age) {
        this.nickname = nickname;
        this.gander = gander;
        this.age = age;
        System.out.println("我是Person类的有参构造方法" );
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getGander() {
        return gander;
    }

    public void setGander(int gander) {
        this.gander = gander;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Boy extends Person {
    public Boy() {
        System.out.println("我是Boy类的无参构造方法");
    }

    public Boy(String nickname, int gander, int age) {
        super(nickname, gander, age);
        System.out.println("我是Boy类的有参构造方法");
    }
}

public class Girl extends Person {
    public Girl() {
        System.out.println("我是Girl类的无参构造方法");
    }

    public Girl(String nickname, int gander, int age) {
        super(nickname, gander, age);
        System.out.println("我是Girl类的有参构造方法");
    }
}

测试：

五:父类的引用指向子类实例化对象实例化时，类型不用Boy , Girl啦，而使用Person这个类型同样可以。因为子类的构造方法是继承父类的，所以类型也可以是父类的。这种现象就叫做父类的引用指向子类实例化对象

public class PersonTest {
    @Test
    public void test06(){
        Person person = new Boy("浩楠",1,20);
        System.out.println("姓名 >>>"+person.getNickname());
        System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));
        System.out.println("年龄 >>>"+person.getAge());
    }
    @Test
    public void test07(){
        Person person = new Girl("韵菡",0,21);
        System.out.println("姓名 >>>"+person.getNickname());
        System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));
        System.out.println("年龄 >>>"+person.getAge());
    }
}

六：子类可以拥有单独的方法注意：子类单独拥有的方法，父类无法直接调用

public class Boy extends Person {
    public void work(){
        System.out.println("工作");
    }
}

public class Girl extends Person {
     public void beauty(){
        System.out.println("美丽");
    }
}

public class PersonTest {
     @Test
    public void test08(){
        Boy boy = new Boy();
        boy.work();
    }
    @Test
    public void test09(){
        Girl girl = new Girl();
        girl.beauty();
    }
}

七：方法重写与方法方法重载

方法的重载：一个类中有多个具有相同名称但参数列表不同的方法，则称为方法重载，如果只需要执行一个 *** 作，具有相同的方法名称将增加程序的可读性。

方法的重写：：方法重写基于继承，子类继承父类，子类可以调用父类的方法，同时子类也可以重写父类中的方法，来实现和父类中不同的业务处理逻辑。重写要求子类中方法与父类中的方法名称相同，参数相同，参数类型相同。当子类调用该方法时，基类中的方法则被覆盖。方法重写即：重写父类方法，同名也同参。例如：人类可以吃

public class Person{
    /**
    * 昵称
    */
    private String nickname;
    /**
     * 性别 1代表男  0代表女
     */
    private int gander;
    /**
     * 年龄
     */
    private int age;

    public void eat(){
        System.out.println("吃吃吃");
    }
}

public class Boy extends Person {
      @Override
    public void eat() {
        System.out.println("吃核桃");
    }
}

public class Girl extends Person {
    @Override
    public void eat() {
        System.out.println("吃荔枝");
    }
}

测试：

public class PersonTest {
      @Test
    public void test08(){
        Boy boy = new Boy();
        boy.work();
        boy.eat();
        Person person = new Boy("浩楠",1,20);
        person.eat();
    }
    @Test
    public void test09(){
        Girl girl = new Girl();
        girl.beauty();
        girl.eat();
        Person person = new Girl("韵菡",0,21);
                person.eat();
    }
}

八：向上转型与向下转型注意：向下转型，在子类中进行一定成功，在父类中进行会报错

public class PersonTest {
@Test
    public void test08(){
        Boy boy = new Boy();
        boy.work();
        boy.eat();
        //向上转型  父类的引用指向子类实例化对象
        Person person = new Boy("浩楠",1,20);
        person.eat();
    }
}

 public class PersonTest { 
 @Test
    public void test010(){
        Person person = new Boy("浩楠",1,20);
        person.eat();
        //向下转型
        Boy boy= (Boy) person;
        boy.eat();
        boy.work();
    }
}

七：final修饰类和方法

final 修饰的类无法被继承

final 修饰的方法无法被重写

1. 当用final关键字修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

2.当用final关键字修饰一个方法时，表明这个方法不能被重写，但是这个方法可以被重载。也就是说我们使用final关键字修饰一个方法时，相当于给这个方法上了一把锁。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/729607.html

JAVA面向对象-----继承

发表评论

评论列表（0条）