Java面向对象的三大特征（封装，继承，多态）

public class Student {
    //成员变量
    private String name;//用private修饰，外部不能直接访问
    private int age;
    //无参构造方法
    public Student(){

    }
    //有参构造方法
    public Student(String name,int age){//this区分成员变量与形参重名问题
        this.name=name;
        this.age=age;
    }

    //成员方法
    public void setName(String name){//根据提供的get(),set()方法，外部可以访问
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println(getName()+"  "+getAge());
    }
}

//测试类
public class Studentdemo {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("林青霞");
        s.setAge(30);
        s.show();


        Student s1=new Student("张曼玉",20);
        s1.show();
    }

}

二、继承

1.继承的概念

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

2.实现继承的格式

继承通过extends实现
格式：class 子类 extends 父类 { }

class Dog extends Animal { }//狗继承动物

3.继承的好处和弊端

3.1继承的好处

提高了代码的复用性(多个类相同的成员可以放到同一个类中)
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

3.2继承的弊端

继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

4.继承中的成员访问特点

4.1继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

class Fu {
    int num = 10;
}
class Zi extends Fu{
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();	// 输出show方法中的局部变量num=30
    }
}

4.2继承中成员方法的访问特点

通过子类对象访问一个方法

子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

4.3super与this的区别

this&super关键字：
- this：代表本类对象的引用
- super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别
- 成员变量：
  - this.成员变量 - 访问本类成员变量
  - super.成员变量 - 访问父类成员变量
- 成员方法：
  - this.成员方法 - 访问本类成员方法
  - super.成员方法 - 访问父类成员方法
构造方法：
- this(…) - 访问本类构造方法
- super(…) - 访问父类构造方法

5.方法重写

5.1方法重写概念

子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

5.2应用场景

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

5.3Override注解

用来检测当前的方法，是否是重写的方法，起到【校验】的作用

 @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }

5.4方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

5.5方法重写与重载的区别

1.重写：方法名一样，参数列表也必须一样

重载：方法名一样，多个方法的参数不相同，类型不同或者数量不同

2.位置：重写在继承类或者实现类

重载在同一个类中

6.继承的注意事项

Java中类只支持单继承，不支持多继承
- 错误范例：class A extends B, C { }
Java中类支持多层继承

public class Granddad {

    public void drink() {
        System.out.println("爷爷爱喝酒");
    }

}

public class Father extends Granddad {

    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }

}

public class Mother {

    public void dance() {
        System.out.println("妈妈爱跳舞");
    }

}
public class Son extends Father {
	// 此时，Son类中就同时拥有drink方法以及smoke方法
}

三、多态

1.多态的概述

1.1什么是多态

同一个对象，在不同时刻表现出来的不同形态

1.2多态的前提

- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象

2.多态的好处和弊端

2.1多态的好处

提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

2.2多态的弊端

不能使用子类的特有成员

3.多态中的成员访问特点

成员访问特点

成员变量

编译看父类，运行看父类
成员方法

编译看父类，运行看子类

//动物类
public class Animal {
    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }
}
//猫类
public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);
//        System.out.println(a.weight);

        a.eat();
//        a.playGame();
    }

4多态中的转型

4.1向上转型

父类引用指向子类对象就是向上转型

4.2向下转型

格式：子类型对象名 = (子类型)父类引用;

结合上面代码演示

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        //向上转型
        Animal a = new Cat();
        a.eat();
//      a.playGame();


        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

卿先生的学习之路

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
Java面向对象的三大特征（封装，继承，多态）

目录文章目录前言一、封装1.封装概述2.封装原则3.封装好处4.封装中两个关键字4.1private关键字4.2this关键字5.代码演示二、继承1.继承的概念2.实现继承的格式3.继承的好处和弊端3.1继承的好处3.2继承的弊端4.继承中的成员访问特点4.1继承中变量的访问特点4.2继承中成员方法的访问特点4.3super与this的区别5.方法重写5.1方法重写概念5.2应用场景5.3Overri...
复制链接

扫一扫