Java面象对向的基本思想（二）

最新推荐文章于 2024-09-23 15:50:28 发布
最新推荐文章于 2024-09-23 15:50:28 发布
阅读量369 收藏 1
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013367928/article/details/52415962
版权

java的多态性

多态性在面向对象中是一个最重要的概念，在Java中面向对象主要有以下两种主要体现：方法的重载与覆写、对象的多态性。实际上对象的多态性体现在对象的向上转型和向下转型。

对象的向上转型

在继承关系中，子类对象向上转型成父类对象的过程就叫做向上转型。向上转型可以自动完成。只需要去定义父类类型的对象去接收就可以了，而在调用方法时，将调用子类覆写以后的方法。并且不能调用单独在子类中定义的方法。

其语法：父类 父类对象 = 子类对象;

父类:

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

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

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

    public void say(){
        System.out.println("姓名："+this.name+" 年龄："+this.age);
    }

    public void play(){
        System.out.println("打牌");
    }
}

子类：

public class Student extends Person {
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public void say() {
        System.out.println("姓名："+this.getName()+" 年龄："+this.getAge()+" 学校："+this.school);
    }

    public void study(){
        System.out.println("学习");
    }
}

测试:

public class Test4 {
    public static void main(String[] args) {
        Student stu = new Student();
        //向上转型
        Person per = stu;
        //被子类覆写以后的方法
        per.say();
        per.play();
        //不能调用的
        //per.study();
    }
}

对象的向下转型

对象的向上转型指的是父类对象向子类对象的转换过程，向下转型的过程必须强制完成。而要想强制转换能够成功，那么该对象必须首先发生对象的向上转型。

public class Test4 {
    public static void main(String[] args) {
        Person per = new Person();
        Student stu = (Student)per;
        System.out.println(stu);
    }
}

如果直接将一个父类的对象转换成子类对象，此时会出现类转换异常：java.lang.ClassCastException

public class Test4 {
    public static void main(String[] args) {
        Person per = new Student();
        Student stu = (Student)per;
        System.out.println(stu);
    }
}

从以上的代码发现，向下转型的意义是存在问题。

使用instanceof关键字去判断对象的类型

在进行向下转型之前，首先需要去判断向下转型的对象是不是一个子类对象，那么这种判断可以使用instanceof来完成。

在进行对象的向下转型过程中，我们必须首先确认是否发生了对象的向上转型，即要向下转型的对象从实质上是不是一个子类的对象。那么针对于这种对象所属类型的判断，可以使用instanceof关键字来完成。

Java中使用Instanceof关键字判断一个对象到底是哪一个类的对象。那么在对象向下转型前可以使用该关键字来进行对象的验证。

public class Test4 {
    public static void main(String[] args) {
        Person per = new Person();
        //使用instanceof进行判断
        if(per instanceof Student){
            System.out.println("本质上是子类对象");
            Student stu = (Student)per;
            System.out.println(stu);
        }else{
            System.out.println("不是子类对象");
        }
    }
}

抽象类的使用

如果一个父类只代表一类事物的抽象的概念，那么这个类就可以定义成抽象类。

包含抽象方法的类必须是抽象类，使用abstract关键字生命的方法就叫做抽象方法，抽象方法只需要声明，不需要进行具体的实现，抽象类可以包含抽象方法，也可以包含普通的成员方法。

其语法如下：

访问修饰权限 abstract class 类名{
  属性;
  方法;
  访问修饰权限 abstract 返回值类型 方法名(参数列表);
}

抽象类不能实例化对象，要使用抽象必须去定义抽象类的子类，子类必须去覆写抽象类中全部的抽象方法。

public abstract class Fruit {
    public abstract void eat();
}
public class Apple extends Fruit {

    @Override
    public void eat() {
        System.out.println("洗洗就可以吃了");

    }


}
public class Test {

    public static void main(String[] args) {
        Fruit f = new Apple();
        f.eat();
    }

}

接口的使用

接口是Java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。其定义语法：

访问修饰符 interface 接口名称{
  全局常量;
  公共的抽象方法;
}
public interface A {
    //全局常量
    public static final String MSG = "info";
    //定义公共的抽象方法
    public abstract void fun();
}

既然接口中只能有全局常量和公共的抽象方法，以上的定义形式也可以简单化。

public interface A {
    //全局常量
    String MSG = "info";
    //定义公共的抽象方法
    void fun();
}

由于接口中存在抽象方法，那么接口不能直接实例化对象，要使用接口那么必须定义接口的实现类。如果实现类不是抽象类，那么必须覆写接口中全部的抽象方法。通过使用implements关键字来完成。

public class AImpl implements A {

    @Override
    public void fun() {
        String msg = this.MSG;
        System.out.println(msg);
    }
}

接口的使用时相当灵活的，使用接口也可以一定程度上接触代码的耦合性。提高代码的可读性。

一个类可以实现多个接口，来同时获取者多个接口中的功能。

接口：

public interface InterfaceA {
    void swim();
}
public interface InterfaceB {
    void fly();
}
public class CImpl implements InterfaceA,InterfaceB{

    @Override
    public void fly() {
    }

    @Override
    public void swim() {
    }

}

同时接口可以进行多继承，这也是java中唯一的多继承

public interface A {
    void fun1();
}
public interface B {
    void fun2();
}
public interface C extends A, B {
    void fun3();
}
public class CImpl implements C{

    @Override
    public void fun1() {
    }

    @Override
    public void fun2() {
    }

    @Override
    public void fun3() {
    }

}

在使用接口的同时，一个类可以既实现接口同时也继承另一个类，这样就避免了java单继承的局限性。

public abstract class AbstractD {
    public abstract void jump();
}
public class CImpl extends AbstractD implements InterfaceA,InterfaceB{

    @Override
    public void fly() {
    }

    @Override
    public void swim() {
    }

    @Override
    public void jump() {
    }

}

抽象类和接口的对比，在既能使用抽象类又能使用接口的情况下，优先使用，这样可以避免单继承的局限性。

这里写图片描述

Object类的使用

在Java中所有的类都有一个公共的父类Object，一个类只要没有明显地继承一个类，则肯定是Object类的子类。Object可以接受任意引用类型的对象，Object类中提供了很多的方法供开发者进行调用。

Object接受任意对象

public class Test {

    public static void main(String[] args) {
        Person per = new Person();
        Pet pet =new Pet();

        print(pet);
    }

    public static void print(Object o){
        System.out.println(o);
    }
}

Object类的常用方法

Object也同时定义了一些常用的方法以供开发人员使用。

Equals()方法，默认是去比较两个对象的地址，如果地址一致，那么返回真，否则返回假，但是比较地址的方式相对不太常用，因为比较地址可以使用“==“，那么在实际开发中经常需要覆写该方法来实现对对象的内容的比较。

public class Person {
    private String name;
    private int age;
    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 Person(){
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }else if(obj instanceof Person){
            Person p = (Person)obj;
            if(this.getName().equals(p.getName())&&this.getAge()==p.getAge()){
                return true;
            }
        }
        return false;
    }
}

toString()在Object中默认是返回当前对象的地址的形式，当我们直接访问类的对象的时候，程序会自动调用该类中的toString方法。

public class Person {
    private String name;
    private int age;
    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 Person(){
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }else if(obj instanceof Person){
            Person p = (Person)obj;
            if(this.getName().equals(p.getName())&&this.getAge()==p.getAge()){
                return true;
            }
        }
        return false;
    }
    @Override
    public String toString() {
        return "name=" + name + ", age=" + age;
    }
}

toString主要的作用就是去输出对象中属性的值，String中已经完成对toString方法的覆写，看来实现返回String对象的内容。

包装类

Java是面向对象的，一切都是类和对象为处理问题的基本组成，但是有一类形式比较特殊，就是基本数据类型。

基本数据类型对应的包装类

这里写图片描述

Integer类型的构造方法的使用:

public class IntegerDemo {
    public static void main(String[] args) {
        int n = 10;
        Integer integer = new Integer(n);
        //直接输出包装类的对象，完成自动的拆箱的操作
        System.out.println(integer);
    }
}
public class IntegerDemo {
    public static void main(String[] args) {
        String n = "aaa123";
        Integer integer = new Integer(n);
        //直接输出包装类的对象，完成自动的拆箱的操作
        System.out.println(integer);
    }
}

以上的操作将出现java.lang.NumberFormatException

自动装箱和拆箱

在了解了包装类的概念以后，下面我们来介绍包装类的装箱和拆箱的概念。将一个基本数据类型变为包装类的对象，这样的过程称为装箱操作，而将一个包装类的对象变为基本数据类型的过程称之为拆箱操作。在JDK1.5以后提供了自动拆箱与装箱操作。

public class IntegerDemo {
    public static void main(String[] args) {
        int n = 10;
        //自动的装箱操作
        Integer integer = n;
        //自动的拆箱操作
        int m = integer;
        System.out.println(m);
    }
}

包装类中提供了将字符串转换成基本数据类型的方法。

public class IntegerDemo {
    public static void main(String[] args) {
        String ss = "12345";
        int n = Integer.parseInt(ss);
        System.out.println(n+1);
    }
}

内部类和匿名内部类

内部类就是定义在一个类的内部的类，如果在一个类Outer的内部再定义一个类Inner，那么类Inner就是内部类，Outer则称为外部类。

内部类可以使用private或者public修饰，其访问限制与类中的属性相同。

public class Outter {
    private String info;
    public void fun(){
        System.out.println(info);
    }

    //声明一个内部类
    public class inner{
        public void fun2(){
            System.out.println("这是内部类的方法");
        }
    }
}

内部类对象的实例化

从定义的语法来看，内部类相当于外部类中的一部分，类是可以通过构造方法来完成实例化，但是该类处于外部类的内部，一个类的内部的普通的成员变量或者方法是必须通过类的对象来进行调用，此时可以得出结论，如果要实例化内部类的对象，必须首先实例化外部类的对象，由外部类的对象调用内部类的构造方法来完成内部类对象的实例化。

public class Test {
    public static void main(String[] args) {
        Outter out = new Outter("Hello");
        Outter.Inner in = out.new Inner();
        in.fun2();
    }
}

以上的实例化内部类对象的操作也可以变为一下的形式：

public class Test {
    public static void main(String[] args) {
        Outter.Inner in = new Outter("Hello").new Inner();
        in.fun2();
    }
}

以上的代码可以发现，内部类的一个主要的作于可以非常方便地访问外部类中的私有的成员变量，但是也同时发现了问题，这种形式打破了原有的类的结构，似的代码的可读性降低。

使用static修饰内部类

使用static可以声明属性或者方法，那么这里也可以使用static修饰内部类，而使用static修饰的内部类将成为外部类。但是使用static修饰的内部类不能访问非static修饰的外部类的属性。

public class Test {
    public static void main(String[] args) {
        Outter.Inner in = new Outter.Inner();
    }
}

使用static修饰内部类以后，内部类只能访问外部类中的static修饰的属性或者方法。

public class Outter {
    private static String info = "Hello";
    public Outter(String info){
        this.info = info;
    }
    public static void fun(){
        System.out.println(info);
    }

    //声明一个内部类
    public static class Inner{
        public void fun2(){
            fun();
            System.out.println(info);
        }
    }
}
吾爱kobe
关注
专栏目录
Java中面向对象的编程思想
yzl1293346757的博客
07-17 913
面向对象的编程思想,学习java必要的基础知识
Java面向对象程序设计思想
qq_45390758的博客
04-09 609
Java语言程序设计面向对象程序设计第一章面向对象程序设计思想1、类和对象2、封装3、继承4、多态5、面向对象的程序设计类的层次结构设计 第一章面向对象程序设计思想 1、类和对象 类描述了一组有相同特性（属性）和相同行为（方法） 的对象，类与对像是面向对像思想的两个核心概念。 面向对象是一种思维方式，其思想符合人们认识现实世界的思维方式，程序开发者从现实生活角度出发，符合人们的思维方式解决编程问题。 在程序中，通常通过定义若干数据类型的变量来表示对象的属性，比如，年龄用一个整数型的变量来标识，性别用字符类型
java面向对象的基本思想_Java 面向对象基本思想的诠释
weixin_36211941的博客
02-13 405
我们都知道java是面向对象的编程，掌握面向对象的编程思想是掌握java编程语言的核心，我们学习Java的第一节课都是要学习面向对象的思想，但我们很多人还沉浸在面向过程的思想中，有的是刚学完C语言，受面向过程思想干扰，在刚刚接触java的时候措手不及，感觉无从下手，我想通过自己对java的学习，用通俗易懂的语言，来总结对面向对象的理解，什么是面向对象？什么是面向对象？面向对象是一种新兴的程序设计方...
Java面向对象思想
qq_36964761的博客
01-09 496
面向对象是一种编程方式，通过对象的方式将现实世界映射到计算机模型的一种表达方法。在解决显示世界问的的过程中对问题进行抽象，通过对象的方式代入到计算机模型中进行解决。其基本思想是使用 抽象、类、对象、封装、继承、多态等基本概念来进行程序设计。
【Java基础】面向对象思想
Ricky的博客
08-14 833
本文介绍了贯穿Java的面向对象思想以及封装和包
Java基础：面向对象思想代码应用
麦田
11-23 424
面向对象思想与应用 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。面向过程类的程序更关注于程序执行的流程，而
【JAVA SE】 java面向对象思想之封装
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
03-27 390
目录 面向对象思想之封装 什么是封装呢？ 封装的好处意义 getter方法和setter方法 toString方法 面向对象思想之封装 或许大家都听说过java是纯面向对象语言，面向对象思想也就是我们常说的OOP,我们听说最多的思想就是继承，封装，多态，今天我们来讲一讲封装。 什么是封装呢？ 封装就是一种将数据和操作数据的方法进行有机结合，一种函数抽象类的接口实现了对细节的封装和隐藏，使得我们只需要调用对外开放的公共接口去实现与对象的交互。我们可以把封装理解为一种保护的屏障，需要一些严格的
java面对对象基本概念以及常见的设计模式
weixin_64549900的博客
06-27 178
java设计模式以及基本概念
Java学习——面向对象编程思想
weixin_53919192的博客
05-25 1876
本文向大家介绍了面对对象的基本概念、面向对象与面向过程的区别、面向对象程序设计的类与对象、面向对象的四大特征：抽象、继承、封装、多态、实现多态性的三种方式：重载、重写、接口、 面向对象思想优点、面向对象思想总结、三大特征、五种关系、七大原则，希望对你有用~~
如何理解java的面向对象思想
weixin_38568503的博客
02-17 177
面试——你是如何理解java的面向对象思想 当面试官问这个问题时： (1)首先，要引申出类：类是面向对象中的一个很重要的概念，因为类是很多个具有相同属性和行为特征的对象所抽象来的，对象是类的一个实例。 (2)然后，围绕类的三个特征来说：封装、继承和多态。可以结合实际生活或者项目开发中的实际场景进行阐述。 (3)如下为个人总结答案，不喜勿喷： (3.1)在我理解,面向对象是一种“万物皆对象”的编程思想。很多个具有相同属性和行为的对象就可以抽象为类，对象是类的一个实例。面向对象在java中正是通过类来实现的。
Java面向对象程序设计
03-17
以上就是对Java面向对象程序设计的详细解析，涵盖了从基础到进阶的关键概念，为学习和掌握Java编程打下坚实的基础。通过深入理解和实践这些知识点，开发者可以构建出高效、稳定且易于维护的Java应用程序。
java基础语法之面向对象
guansh233的博客
03-12 407
关于面向对象语法的学习总结
Java基础面试~面向对象篇
qq_45058113的博客
04-02 538
1.谈一谈你对面向对象的理解？ 谈面向对象，就要和面向过程一起说； 面向过程思想，步骤清晰简单，第一步做什么，第二部做什么，适合处理一些简单的问题，比如说洗衣服，先将衣服扔进洗衣机，然后倒入洗衣粉，再关闭洗衣机，最后按开始按钮，就这么简单！ 面向对象思想，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的探索，适合处理复杂的问题，适合处理需要多人协作的问题！比如说建一栋楼，需要一个总设计师，然后总设计师提出规划，打地基的打地基，拉材
微服务--Gateway网关
最新发布
weixin_51933701的博客
09-23 914
Zuul是Spring Cloud早期版本中广泛使用的网关组件，它基于Netflix Zuul构建。Zuul提供了路由、负载均衡、容错、安全性等多种功能，是微服务架构中API网关的常用选择之一。然而，需要注意的是，随着Spring Cloud的发展，Zuul逐渐进入维护模式，Spring Cloud官方推荐使用Spring Cloud Gateway作为替代方案。
Android系统：系统架构
liufeismart2024的博客
09-23 305
Android的系统结构的设计混合了分层设计和分块设计。
JDK17新增语法特性
2201_76124988的博客
09-20 752
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 260
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 1114
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 2074
金九银十多线程和IO大厂面试专题
java面相对象 内部类
07-25
在Java中，内部类是定义在另一个类内部的类。它们可以访问外部类的成员，包括私有成员，并且可以提供更好的封装性和代码组织性。 Java中有四种类型的内部类： 1. 成员内部类（Member Inner Class）：定义在另一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值