Java编程思想-面向对象

最新推荐文章于 2022-07-17 22:00:37 发布

长歌"

最新推荐文章于 2022-07-17 22:00:37 发布

阅读量115

点赞数

分类专栏：基础学习笔记

本文链接：https://blog.csdn.net/qq_44262458/article/details/119185696

版权

基础学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文介绍了面向对象编程的核心概念，包括封装、继承、多态和抽象类。通过实例展示了如何在Java中实现这些概念，如Phone类的封装、Student类的封装和继承、Animal类的继承以及多态的应用。同时，讲解了方法重写、访问权限修饰符的作用，并探讨了抽象类和抽象方法的使用。最后，提到了final和static关键字的重要性。

摘要由CSDN通过智能技术生成

简单类举例

package com.itcast.demo;

public class Phone {
    String model;
    String brand;
    String name;


    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }

    public void send(String name) {
        System.out.println("给" + name + "发信息");
    }

    public void play() {
        System.out.println("玩游戏");
    }
}

package com.itcast.demo;

public class PhoneTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.name = "asd";
        phone.brand = "小米";
        phone.model = "12";
        phone.call("小安");
        phone.send("小黑");
        phone.play();
    }
}

封装

封装的好处

提高安全性
提高复用性
将复杂的事情简单化

private的基本概念

私有的，一种访问权限修饰符，用来修饰类的成员

特点

被修饰的成员只能在本类中访问

用法

private 数据类型变量名;

private 返回值类型方法名(参数列表) { }

this关键字

this的基本概念

这，这个，表示本类对象的引用，本质是一个对象

特点

每一个普通方法都有一个this，谁调用该方法，this就指向谁

用法

this.属性名; this.方法名(参数);

package com.itcast.demo;

public class StudentTest {
    public static void main(String[] args) {
        Student stu = new Student();
        Student stu1 = new Student("张三", 19);
        System.out.println(stu1.getName());
        System.out.println(stu1.getAge());
    }
}

package com.itcast.demo;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {

    }

    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;
    }

}

继承

通过扩展一个类来建立另外一个类的过程，叫做继承（inheritance）通俗地说，所谓继承，就是让类与类之间产生父子关系。所有的类都直接或间接的继承自： java.lang.Object 被继承的类叫做父类（基类、超类）继承的类叫做子类（派生类）

格式（extends）

子类继承父类之后有什么效果？

子类拥有了父类的非私有成员（成员变量、成员方法）

父类Animal：

package com.itcast.demo2;

public class Animal {
    private String name;
    private int age;
    private String sex;

    public Animal() {
    }

    public Animal(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

子类Dog：

package com.itcast.demo2;

public class Dog extends Animal {
    public void eat() {
        System.out.println("小狗" + getName() + "爱吃骨头");
    }

    public void speak() {
        System.out.println("小狗" + getName() + "汪汪叫");
    }
}

子类Pig：

package com.itcast.demo2;

public class Pig extends Animal {
    public void sleep() {
        System.out.println("小猪" + getName() + "爱睡觉");
    }
}

测试类：

package com.itcast.demo2;

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog dog1 = new Dog();
        Pig pig = new Pig();
        dog.setName("望望");
        dog1.setName("猜猜");
        pig.setName("珠珠");
        dog.eat();
        dog1.speak();
        pig.sleep();
    }
}

方法重写（Override）

定义：

子类中出现和父类方法定义相同的方法的现象

解释：

方法重写也叫方法的复写、覆盖
方法名、参数列表、返回值类型都相同

注意事项：

父类私有方法无法重写
子类方法访问权限不能小于父类方法
子类不能比父类方法抛出更大的异常（了解）

使用场景：

扩展父类功能父类功能过时，重新实现父类功能

访问权限修饰符

private：强调给自己使用

默认：强调给同包下的类来使用

protected：强调给子类使用

public：强调给大家使用

方法重写和方法重载的区别：

方法重载：同一个类中，出现两个或两个以上同名方法时，其参数列表不同，称为方法重载，与返回值类型和修饰符无关。

方法重写：子类出现和父类相同的方法时称为方法重写，要求参数列表和返回值相同。

继承的特点

多态

什么是多态？

多种状态，同一对象在不同情况下表现出不同的状态或行为

Java中实现多态的步骤

要有继承（或实现）关系
要有方法重写
父类引用指向子类对象（is a关系）

package com.itcast.demo3;

public class Animal {
    private String name;

    public Animal() {
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

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

package com.itcast.demo3;

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println(getName()+"吃骨头");
    }
}

package com.itcast.demo3;

public class Test {
    public static void main(String[] args) {

        Animal a = new Dog();
        a.setName("小黑");
        a.eat();

    }
}

多态的好处和弊端

多态的好处

可维护性：

基于继承关系，只需要维护父类代码，提高了代码的复用性，大大降低了维护程序的工作量

为什么要学习多态：

从程序的模块化和复用性来解释

封装：隐藏数据的实现细节，让数据的操作模块化，提高代码复用性

继承：复用方法，从对象的行为这个层面，提高代码的复用性

多态：复用对象，程序运行时同一个对象表现出不同的行为

可扩展性：

把不同的子类对象都当作父类看待，屏蔽了不同子类对象间的差异，做出通用的代码，以适应不同的需求，实现了向后兼容

多态的弊端

不能使用子类特有成员

解决办法：

向下转型（前提：必须准确知道该父类引用指向的子类类型）

类型转换

当需要使用子类特有功能时，需要进行类型转换

向上转型（自动类型转换）

// 子类型转换成父类型

Animal animal = new Dog();

向下转型（强制类型转换）

// 父类型转换成子类型

Dog dog = (Dog)animal;

注意事项

只能在继承层次内进行转换，否则可能造成异常（ ClassCastException ）将父类对象转换成子类之前，使用 instanceof 进行检查

package com.itcast.demo4;

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

package com.itcast.demo4;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void watch() {
        System.out.println("狗会看家");
    }
}

package com.itcast.demo4;

public class Test {
    public static void main(String[] args) {
        Animal an = new Dog();
        an.eat();

        //向下转型 instanceof判断类型是否可以转换
        if (an instanceof Dog) {
            Dog dog = (Dog) an;
            dog.watch();
        }
    }
}

抽象类

抽象类的概念

包含抽象方法的类。用abstract修饰

抽象方法的概念

只有方法声明，没有方法体的方法。用abstract修饰

抽象方法的由来

当需要定义一个方法，却不明确方法的具体实现时，可以将方法定义为abstract，具体实现延迟到子类

package com.itcast.demo5;

//抽象类
public abstract class Animal {
    //抽象方法(要求子类必须重写)
    public abstract void eat();
}
package com.itcast.demo5;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
package com.itcast.demo5;

public class Mouse extends Animal {
    @Override
    public void eat() {
        System.out.println("老鼠吃奶酪");
    }
}
package com.itcast.demo5;

public class Test {
    public static void main(String[] args) {

        //老鼠类
        Animal m = new Mouse();
        m.eat();

        //狗类
        Animal d = new Dog();
        d.eat();
    }
}

抽象类的特点

抽象类成员的特点

成员变量： 可以有普通的成员变量，也可以有成员常量（final）

成员方法： 可以有普通方法，也可以有抽象方法抽象类不一定有抽象方法，有抽象方法的类一定是抽象类（或接口）

构造方法： 像普通类一样有构造方法，且可以重载。

final关键字

final的作用

用于修饰类、方法和变量

修饰类： 该类不能被继承（可以继承别人）

String, System

修饰方法： 该方法不能被重写不能与abstract共存

修饰变量： 最终变量，即常量，只能赋值一次不建议修饰引用类型数据，因为仍然可以通过引用修改对象的内部数据，意义不大。

static关键字

static的作用

用于修饰类的成员：成员变量：类变量成员方法：类方法

调用方式类名. 成员变量名; 类名. 成员方法名(参数);

static修饰成员变量

特点： 被本类所有对象共享

接口

package com.itcast.demo7;

public interface Smoking {
    public abstract void smoke();
}

public class People implements Smoking {

    @Override
    public void smoke() {
        System.out.println("吸烟有害健康");
    }
}

public class Test {
    public static void main(String[] args) {
        Smoking s = new People();
        s.smoke();
    }
}

长歌"

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java编程思想-面向对象

简单类举例package com.itcast.demo;public class Phone { String model; String brand; String name; public void call(String name) { System.out.println("给" + name + "打电话"); } public void send(String name) { System.out.
复制链接

扫一扫