Java基础之面向对象详解

举报
小小张自由--张有博 发表于 2021/11/24 00:16:15 2021/11/24
【摘要】     目录 什么是类? 什么是对象? 面向对象的三大特性(封装、继承、多态) 一、封装 访问修饰符 关键字this的含义 二、继承 继承后的特点--成员变量 继承后的特点--成员方法 super和this的含义 父类空间由于子类对象产生 三、多态 多态存在的条件: 创作不...
 
 

目录

什么是类?

什么是对象?

面向对象的三大特性(封装、继承、多态)

一、封装

访问修饰符

关键字this的含义

二、继承

继承后的特点--成员变量

继承后的特点--成员方法

super和this的含义

父类空间由于子类对象产生

三、多态

多态存在的条件:

创作不易,如果本篇博客对您有一定的帮助,大家记得留言+点赞哦。


       对 Java 语言来说,一切皆是对象。把现实世界中的对象抽象地体现在编程世界中,一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计,这些对象可以是独立存在的,也可以是从别的对象继承过来的。对象之间通过相互作用传递信息,实现程序开发。

什么是类?

是对象的抽象,它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法,其中成员变量用于描述对象的特征,也被称之为属性,成员方法用于描述对象的行为,简称为方法。


      public class Student {
         //成员变量
         private String name;//姓名
         private int age;//年龄
         //成员方法
         //学习的方法
         public  void study(){
              System.out.println("好好学习,天天向上");
          }
         //吃饭的方法
         public void eat(){
              System.out.println("干饭人干饭时间");
          }
         @Override
         public String toString() {
             return "Student{" +
                     "name='" + name + '\'' +
                     ", age=" + 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 Student(String name, int age) {
             this.name = name;
             this.age = age;
          }
         //无参构造函数
         public Student() {
          }
  
 

什么是对象?

对象 :是一类事物的具体体现。对象是类的一个 实例 (对象并不是找个女朋友),必然具备该类事物的属性和行为。

       public static void main(String[] args) {
           //创建对象
            Student stu1=new Student("张三",9);
            Student stu2=new Student("李四",9);
           //使用对象访问类中的成员
            stu1.setAge(18);
            stu1.eat();
            stu2.setName("赵四");
            stu2.study();
       }
   
  

面向对象的三大特性(封装、继承、多态)

一、封装

封装:封装是面向对象方法的一个重要原则,它有两个含义:第一个含义是,把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象);第二个含义也称作信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界,只保留有限的对外接口使之与外部发生联系。

    1.使用private关键字来修饰成员变量

    2.对需要访问的成员变量,提供对应的一对getXxx方法、SetXxx方法。


        public class Student {
          //私有成员变量
          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;
           }
       }
   
  

访问修饰符

关键字this的含义

  • this代表所在类的当前对象的引用(地址值),即对象自己的引用。
  • 方法被哪个对象调用,方法中的this就代表哪个对象。即谁在调用,this就代表谁。

变量封装了当前值,方法封装了代码和行为,类封装两者以同时提供一堆状态和函数。接口封装了方法。

二、继承

继承:继承是一种使用户得以在一个类的基础上建立新的类的技术。新的类自动继承旧类的属性和行为特征,并可具备某些附加的特征或某些限制。

继承就是子类继承父类的属性和行为,使得子类具有与父类相同的属性、相同的行为。子类可以直接访问父类的非私有的属性和行为。

提高了代码的复用性。类与类之间产生了关系,是多态的前提


      class 父类{
          ···
      }
      class 子类 extends 父类{
          ···
      }
  
 
 

继承后的特点--成员变量

      如果子类父类出现不同名的成员变量,代码的访问没有影响。

      如果子类父类出现了同名的成员变量,在子类中需要访问父类中非私有成员变量是,需要使用super关键字,修饰父类的成员变量


      class Zi extends Fu {
         // Zi中的成员变量
         int num = 6;
         public void show() {
             //访问父类中的num 
              System.out.println("Fu num=" + super.num);
             //访问子类中的num 
              System.out.println("Zi num=" + this.num);
          }
      }
  
 

继承后的特点--成员方法

        如果子类父类出现不同名的成员方法,代码的访问没有影响。

        如果子类父类出现了同名的成员方法,这时出现了方法重写(Override)

       方法重写:子类中出现与父类一模一样的方法是(返回值类型、方法名和参数列表都相同),会出现覆盖效果。声明不变,重新实现。


      //父类
      class Fu {
         public void show() {
              System.out.println("Fu show");
          }
      }
      //子类
      class Zi extends Fu {
         //子类重写了父类的show方法 
         public void show() {
              System.out.println("Zi show");
          }
      }
      //测试类ExtendsDemo
      public class ExtendsDemo{
         public static void main(String[] args) {
             Zi z = new Zi();
             // 子类中有show方法,只执行重写后的show方法 
              z.show(); // Zi show 
          }
      }
  
 

super和this的含义

  •   super:代表父类的存储空间标识,只能出现在方法中(可以理解父类的引用)
  •   this:代表当前对象的引用(谁调用就代表谁)。

父类空间由于子类对象产生

       在每次创建子类对象时,先初始化父类空间,再创建子类对象本身。目的在于子类对象中包含了其对应的父类空间,便可以包含其父类的成员,如果父类成员非private修饰,子类可以随意使用父类成员。代码体现在子类的构造方法调用时,一定先调用父类的构造方法。

三、多态

多态:在收到消息时对象要予以响应,不同的对象收到同一消息可以产生完全不同的结果, 这一现象叫做多态。

多态存在的条件:

  • 1.存在继承关系
  • 2.方法需要重写
  • 3.父类的引用指向子类

      //子类的引用 指向——> 子类
      父类类型  变量名 = new 子类对象;
      变量名.方法名();
  
 

父类类型:指子类对象继承父类类型,或者实现的父接口类型。 多态是方法的多态,属性没有多态。


      //抽象的父类
      public abstract class Animal {
         public abstract void eat();
      }
      //子类Cat
      class Cat extends Animal {
         public void eat() {
              System.out.println("吃鱼");
          }
      }
      //子类Dog
      class Dog extends Animal {
         public void eat() {
              System.out.println("吃骨头");
          }
      }
      //测试类Test
      public class Test {
         public static void main(String[] args) {
             // 多态形式,创建对象 
             Animal a1 = new Cat();
             // 调用的是 Cat 的 eat 
              a1.eat();
             // 多态形式,创建对象 
             Animal a2 = new Dog();
             // 调用的是 Dog 的 eat 
              a2.eat();
          }
      }
  
 

在多态的代码中,成员方法的访问规则是:   看new的是谁,就优先用谁,没有则向上找。

创作不易,如果本篇博客对您有一定的帮助,大家记得留言+点赞哦。

文章来源: blog.csdn.net,作者:小小张自由—>张有博,版权归原作者所有,如需转载,请联系作者。

原文链接:blog.csdn.net/promsing/article/details/112387314

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。