Java面向对象2-核心特性

山不在高3

已于 2023-12-05 14:36:06 修改

阅读量105

点赞数 1

分类专栏：学习笔记文章标签： java 开发语言后端

于 2022-02-17 20:11:46 首次发布

本文链接：https://blog.csdn.net/Johnny_ch15/article/details/122955977

版权

学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

封装（Encapsulation）

概念：将某一些东西隐藏，然后提供相应的方式进行获取
好处：提高了代码的安全性

package yes.JavaSE.OOP;

public class JavaSE_220216_CGirl {

    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 30){
            this.age = 18;
        }else{
            this.age = age;
        }
    }
}

package yes.JavaSE.OOP;

public class JavaSE_220216_BInheritanceTest {
    public static void main(String[] args) {
        JavaSE_220216_CGirl g = new JavaSE_220216_CGirl();
        g.setAge(10);
        System.out.println(g.getAge());
    }
}

对于属性age来说，加了private之后外界对它的访问就受到了限制，这个时候我们可以通过定义方法，来进行限制条件的添加
进行封装：
（1）将属性私有化，被权限修饰符private修饰
（2）提供public修饰符的方法，来让别人来访问
（3）即使外界可以通过方法来访问，也不能随意访问，可以加一些限制条件

继承（Inheritance）

类是对对象的抽象

举例：荣耀20，小米红米3，华为 p40 pro —》类：手机类

继承是对类的抽象

举例：学生类（属性、方法）、教师类（属性、方法）[子类、派生类]—》人类（共有属性、共有方法）[父类、基类、超类]

继承的好处：提高代码的复用性
父类定义的内容，子类可以直接拿过来用，不用重复定义

package yes.javase.oop.JavaSE_220217_CInherenceTest;

public class Person {
    private String name;
    private int age;
    private double height;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

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

    public void sleep(){
        System.out.println("i can sleep");
    }
}


package yes.javase.oop.JavaSE_220217_CInherenceTest;

public class Student extends Person{
    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    private int sno;

    public void study(){
        System.out.println("i can study");
    }

}


package yes.javase.oop.JavaSE_220217_CInherenceTest;

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        //需要注意的点
        //父类private修饰的内容，子类实际上也继承了，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式
        s.setSno(10001);
        s.setAge(18);
        s.setName("zhangsan");
        s.setHeight(180.2);
        System.out.println(s.getName()+"--"+s.getAge()+"--"+s.getHeight()+"--"+s.getSno());

        s.eat();
        s.sleep();
        s.study();
    }
}

总结：
1、继承关系
父类/基类/超类
子类/派生类
子类继承父类一定在合理的范围内进行，子类extends父类
2、继承的好处
（1）提高了代码的复用性，父类定义的内容，子类可以直接拿过来用，不用重复定义
（2）便于代码的扩展
（3）为了以后多态的使用，是多态的前提
3、父类private修饰的内容，子类实际上也继承了，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式
4、一个父类可以有多个子类
5、一个子类只能有一个直接父类，但可以间接的继承自其他类，Object类是所有类的根基父类，所有类都直接或者间接地继承自Object类
6、继承具有传递性

内存分析
在这里插入图片描述 权限修饰符

protected 在不同包的子类中也可以被访问到
属性、方法：private、缺省、protected、public四种修饰符
类：缺省、public两种修饰符
一般情况下，属性用private修饰，方法用public修饰

方法的重写

子类对父类提供的方法不够用，对父类的方法可以进行重写

要求：
（1）子类方法名和父类必须一致
（2）子类参数列表（个数，类型，顺序）也要和父类一致

重载和重写的区别

重载（overload）：同一个类中，方法名相同，形参列表不同的时候，多个方法构成了重载
重写（override）：在父类子类中，子类对父类提供的方法不够用，对父类的方法可以进行重写

在这里插入图片描述
super关键字的使用

在子类的方法中，可以通过super.属性、super.方法的方式，显式地调用父类提供的属性、方法

（1）通常情况下，super.可以省略不写
（2）特殊情况下，如果父类和子类中，有相同名称的（属性）、重写的（方法），需要调用父类提供的属性、方法的时候super.就不可以省略

super修饰构造器

其实我们平时写的空构造器的第一行，都有super()，作用是调用父类的空构造器，只是一般情况下省略不写
如果构造器已经显示的调用了父类的构造器，super()就不会默认分配了
在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行
IDEA快捷键可以自动生成构造器：alt/option+insert

在这里插入图片描述

equals()方法

==的作用是比较左右两侧的值是否相等，要么相等，返回true，要么不想等，返回false
Object类提供了一个方法equals方法，比较对象具体内容是否相等，但也是在比较地址，没有实际意义
我们在子类中重写equals：

    public boolean equals(Object obj) {
        if(obj instanceof Phone){
            Phone obj2 = (Phone)obj; //将obj转为phone类型
            return (this.getBrand() == obj2.getBrand() && this.getPrice() == obj2.getPrice() && this.getYear() == obj2.getYear());
        }else{
            return false;
        }
    }

类和类产生关系

（1）将一个类作为另外一个类的方法的形参（可以换）
（2）将一个类作为另一个类的属性（更密切，生来具有）

先有父类，再有子类 — 继承
先有子类，再抽取父类 — 泛化

多态（Polymorphism）

多态和属性无关，多态指的是方法的多态，而不是属性的多态

package yes.javase.javase_220222_a_polymorphism_test;

public class Animal {
    public void shout(){
        System.out.println("animal shout");
    }
}


package yes.javase.javase_220222_a_polymorphism_test;

public class Cat extends Animal{
    public void shout(){
        System.out.println("cat shout");
    }
    public void scratch(){
        System.out.println("cat scratch");
    }
}


package yes.javase.javase_220222_a_polymorphism_test;

public class Dog extends Animal{
    public void shout(){
        System.out.println("dog shout");
    }
    public void guard(){
        System.out.println("dog guard");
    }
}


package yes.javase.javase_220222_a_polymorphism_test;

public class Girl {
/*    public void play(Cat c){
        c.shout();
    }*/
/*    public void play(Dog d){
        d.shout();
    }*/
    public void play(Animal a) {
        a.shout();
    }
}


package yes.javase.javase_220222_a_polymorphism_test;

public class Test {
    public static void main(String[] args) {
//        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        Girl g = new Girl();
//        g.play(c);
//        g.play(d);
        Animal a1 = c;
        g.play(a1);
        Animal a2 = d;
        g.play(a2);
    }
}

多态的概念

多态就是多种状态，同一个行为，不同的子类表现出来不同的形态
多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为

多态的好处

为了提高代码的扩展性
开闭原则：指的就是扩展是开放的，修改是关闭的
多态非常负责面向对象的开闭原则的理念

多态的要素

继承：cat extends animal，pig extends animal，dog extends animal
重写：子类对父类的方法重写
父类引用指向子类对象：Animal a = new Cat();
– -》左侧：编译期的类型
– -》右侧：运行期的类型

内存分析

在这里插入图片描述
向下转型和向上转型

package yes.javase.javase_220222_a_polymorphism_test;

public class Test {
    public static void main(String[] args) {
//        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        Girl g = new Girl();
//        g.play(c);
//        g.play(d);
        Animal a = c; //向上转型：子类转父类
        g.play(a);
//        Animal a = d;
//        g.play(a);

        //加入转型的代码
        //将animal转为cat
        Cat cat = (Cat)a; //向下转型：父类转子类

        System.out.println(cat.weight);
        cat.eat();
    }
}

山不在高3

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象2-核心特性

封装（Encapsulation）概念：将某一些东西隐藏，然后提供相应的方式进行获取好处：提高了代码的安全性package msb.JavaSE.OOP;public class JavaSE_220216_CGirl { private int age; public int getAge() { return age; } public void setAge(int age) { if(age >= 30){
复制链接

扫一扫

专栏目录