首页 > 编程语言 >面向对象编程

面向对象编程

时间：2022-12-14 14:45:41浏览次数：65  
标签：name void System 面向对象编程 println public out

面向对象编程

Java的核心思想是oop

  1. 初识面向对象

  2. 方法的回顾与加深

  3. 对象的创建分析

  4. 面向对象的三大特性

  5. 抽象类和接口

  6. 内部类及oop实战

面向过程&面向对象

面向过程思想

  • 步骤清晰简单，第一步做什么，第二步做什么

  • 面对过程适合处理一些较为简单的问题

面对对象思想

  • 物以类聚，分类的思想模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索

  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题

对于描述复杂的实物，为了从宏观上把握、从整体上合理的分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象

  • 面向对象编程（Object-Orineted Programming，OOP）

  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

  • 抽象

  • 三大特性：

    • 封装

    • 继承

    • 多态

  • 从认识论角度考虑是先有对象后有类。对象，是具体的事物；类，是抽象的，是对对象的抽象

  • 从代码运行角度考虑是先有类，后有对象。类是对象的模板

回顾方法以及加深

  • 方法的定义

    • 修饰符

    • 返回类型

    • break和return的区别

    • 方法名：注意规范，见名知意

    • 参数列表 （参数类型，参数名）

    • 异常抛出

      package com.fisherstudy.oop;
      ​
      import java.io.IOException;
      ​
      //类
      public class Demo01 {
          //main方法
          public static void main(String[] args) {
      ​
          }
         /*修饰符 返回值类型 方法名(...){
          //方法体
          return 返回值;//返回一个结果，并且结束方法！
         }
         */
           public String sayHello(){
               return "Hello,World!";
           }
          public int Max(int a,int b){
               return a>b?a:b; //三元运算符
          }
          public void print(){
               return;
          }
          public void readFile(String file) throws IOException {
      ​
          }
      }
      ​

       

  • 方法的调用

    • 静态方法的调用

      package com.fisherstudy.oop;
      ​
      public class Student {
          public static void say(){
              System.out.println("说毛啊说");
          }
      }

      调用如下：

      package com.fisherstudy.oop;
      ​
      public class Demo02 {
          //静态方法：static的调用
          public static void main(String[] args) {
              Student.say();
          }
      }

      运行结果如下：

      说毛啊说

       

    • 非静态方法

      package com.fisherstudy.oop;
      ​
      public class Student {
          public  void say(){
              System.out.println("说毛啊说");
          }
      }

      调用如下：

      package com.fisherstudy.oop;
      ​
      public class Demo02 {
          //非静态方法的调用：new创建对象来调用，实例化这个类
          //对象类型 对象名=对象值；
          public static void main(String[] args) {
              Student student = new Student();
              student.say();
      ​
          }
      }
      ​

      运行结果如下：

      说毛啊说

      补充扩展：

      如下例方法可以互相调用

       public  void a(){
              b();
          }
          public void b(){
      ​
          }

      如下例方法不可以直接互相调用

        //static和类一起加载的
          public  static void a(){
              b();
          }
          //类实例化之后才存在
          public void b(){
      ​
          }
      }

       

    • 形参和实参

      package com.fisherstudy.oop;
      ​
      public class Demo03 {
          public static void main(String[] args) {
              //实际参数和形式参数的类型要一一对应
              int  c =Demo03.add(2,3);
              System.out.println(c);
          }
          public static int add(int a,int b){
              return a+b;
          }
      }
      ​

      运行结果如下：

      5

       

    • 值传递和引用传递

      1，值传递：

      package com.fisherstudy.oop;
      ​
      public class Demo04 {
          //值传递
          public static void main(String[] args) {
                   int a=1;
              System.out.println(a);
              Demo04.change(3);
              System.out.println(a);
          }
          //返回值为空
          public static void change(int a){
              a=10;
          }
      }
      ​

      运行结果如下：

      1
      1

      2，引用传递：

      package com.fisherstudy.oop;
      ​
      public class Demo05 {
            //引用传递：对象，本质还是值传递
          public static void main(String[] args) {
              Person person = new Demo05().new Person();//百度结果，非静态内部类，要先引用外部类才能创建
              System.out.println(person);//null
              Demo05.change(person);
              System.out.println(person.name);
          }
          public static void change(Person person){
              //person是一个对象：指向的是...>>Person person = new Person();这是一个具体的人，可以改变属性
              person.name="小猪崽";
          }
          //定义了一个Person类，有一个属性：name
         class Person{
              String name;
        }
      }
      ​

      扩展（百度后得到的结果）：

      1：非静态内部类，必须有一个外部类的引用才能创建。

      2：在外部类的非静态方法中，因为有隐含的外部类引用this，所以可以直接创建非静态内部类。

      3：在外部类的静态方法中，因为没有this，所以必须先获得外部类引用，然后创建非静态内部类。

      4：静态内部类，不需要外部类引用就可以直接创建。

      5：同时静态的内部类，也不能直接访问外部类的非静态方法。

      6：由此可以推测，非静态内部类之所以可以直接访问外部类的方法，是因为创建非静态内部类时，有一个隐含的外部类引用被传递进来。

       

    • this关键字

       

类与对象的创建

1，类是一种抽象的数据类型，它是对某一类实物整体的描述/定义，但是并不能代表某一个具体的实物

比如：动物，植物，手机，电脑

Person类，Cat类，Car类等这些类用来描述/定义某一类具体的实物应该具备的特点

2，对象是抽象概念的具体事例

张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例

能够体现出具体特点，展现出功能的是一个具体的实例，而不是一个抽象的概念

package com.fisherstudy.oop.demo02;
​
public class Student {
    //属性：字段
    String name;//默认的是null
    int age;//默认的是0
    //方法
    public void study(){
        System.out.println(this.name+"在学习！");
    }
​
}
package com.fisherstudy.oop.demo02;
​
public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象
        //s1和s2是Student类的具体实例
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1.name);
        System.out.println(s1.age);
        s1.name="小明";
        s1.age=10;
        s2.name="小红";
        s2.age=12;
        System.out.println(s1.name);
        System.out.println(s1.age);
        System.out.println(s2.name);
        System.out.println(s2.age);
        s1.study();
        s2.study();
    }
}
​

运行结果如下：

null
0
小明
10
小红
12
小明在学习！
小红在学习！

 

创建与初始化对象

使用new关键词创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象，进行默认的初始化以及对类中构造器的调用；

类中的构造器也成为方法，在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：

1，必须和类的名字相同；

2，必须没有返回类型，也不能写void

package com.fisherstudy.oop.demo02;
​
public class Person {
   //一个类即使什么都不写，它也会存在有一个默认的方法
    //显示的定义一个
    String name;
    //实例化初始值
    //1，使用new关键字，本质是在调用构造器
    //2，用来初始化值
​
    public Person(){
​
    }
    //有参构造器:一定定义了有参构造，无参构造就必须显示定义
    //
    public Person(String name){
        this.name=name;
    }
    //alt+insert快捷键构造方法
​
}
package com.fisherstudy.oop.demo02;
​
public class Application {
    public static void main(String[] args) {
        //使用new实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);//null
    }
​
}

运行结果如下：

null

如果给person传入一个字符串参数，则会自动调用有参数的对应的方法：

package com.fisherstudy.oop.demo02;
​
public class Application {
    public static void main(String[] args) {
        //使用new实例化了一个对象
        Person person = new Person("小牛崽");
        System.out.println(person.name);
    }
​
}

运行结果如下：

小牛崽

总结：

构造器：
       1，和类名相同
       2，没有返回值
 作用：
       1，new本质是在调用构造方法
       2，初始化对象的值
 注意点：
       1，定义了有参构造之后，如果想用无参构造，则必须显示一个无参构造
  快捷键：
        Alt+Insert

创建对象内存分析

现有如下代码：

Application类：

package com.fisherstudy.oop.demo02;
​
public class Application {
    public static void main(String[] args) {
        //使用new实例化了一个对象
        Pet dog = new Pet();
        dog.name="妮蔻";
        dog.age=1;
        dog.barrk();
        System.out.println(dog.name);
        System.out.println(dog.age);
        Pet cat = new Pet();
        cat.name="猫咪";
        cat.age=2;
        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.shout();
    }
​
}

Pet类：

package com.fisherstudy.oop.demo02;
​
public class Pet {
    public String name;
    public int age;
    //无参构造
    public void barrk(){
        System.out.println("叫了一声“汪汪”");
    }
    public void shout(){
        System.out.println("叫了一声“喵”");
    }
​
​
}
​

运行结果如下：

叫了一声“汪汪”
妮蔻
1
猫咪
2
叫了一声“喵”

内存分析图：

创建对象内存分析

总结：

1，类与对象

类是一个模板：抽象的；而对象是一个具体的实例

2，方法

定义与调用

3，对象的引用

引用类型 对象是通过引用来操作的：栈------>堆（指向对象的一个地址）

基础类型（八大数据类型）

4，属性

字段 Field 成员变量

默认初始化：

数字 0，0.0

char u0000

boolean false

引用 null

定义方式：修饰符 属性类型 属性名 =属性值；

5，对象的创建与引用

  • 必须要使用new关键字来创建，构造器，Person person=new Person();

  • 对象的属性 person.neme;

  • 对象的方法 person.say();

6，类：

静态的属性 属性

动态的方法 方法

标签：name,void,System,面向对象编程,println,public,out
From： https://www.cnblogs.com/Fisherstudy/p/16982110.html

相关文章

  • Day7 - 面向对象编程进阶
    本节内容：面向对象高级语法部分经典类vs新式类静态方法、类方法、属性方法类的特殊方法反射异常处理Socket开发基础作业：开发一个支持多用户在线的FTP程序 1.经典类......
  • Chapter7_成为会使用面向对象编程的程序员吧
    理解面向对象编程热身问答Object翻译成中文是什么？对象对象（Object）是表示事物的抽象名词。OOP是什么的缩略语？ObjectOrientProgramming面向对象也可以简称......
  • js 实例对象 面向对象编程
     1、对象是什么面向对象编程（ObjectOrientedProgramming，缩写为OOP）是目前主流的编程范式。它将真实世界各种复杂的关系，抽象为一个个对象，然后由对象之间的分工与合作，......
  • 任务12 面向对象编程方法进阶
    一、魔术方法以'__'包起来的方法魔术方法不需要调用就可以自动执行常用的四种魔术方法：__init__();__new__();__del__();__str__()（1）__init__()：初始化方法，类实例化时......
  • 面向对象编程三大特性------封装、继承、多态(概念理解，应用举例)
    1.面向对象&面向过程面向过程思想步骤清晰简单，第一步做什么，第二步做什么....面向过程适合处理一些简单的问题。面向对象思想物以类聚，在思考问题解决方案时会先......
  • 第11章 面向对象编程：继承（笔记）
    11.1简介为了复用11.2基类和派生类父类与子类11.3基类和派生类之间的关系11.4派生类中的构造函数和析构函数11.5public、protected、private继承权限11.6继承......
  • 第12章 面向对象编程：多态性
    12.1简介程序通用化12.2多态性介绍：多态视频游戏12.3类继承层次中对象之间的关系12.4类型域和switch语句12.5抽象类和纯virtual函数跟一个表格有关12.6实例研究......
  • H5游戏开发-面向对象编程
    七、面向对象编程1.认识类与对象类是一种复杂的数据结构，他是将不同类型的数据与这些数据相关的操作封装在一起的集合体。对象是类的实例，是类描述的具体事物。（类是对象的......
  • Java基础---面向对象编程
    什么是面向对象？1.面向过程思想答：线性过程第一步做什么第二步做什么2.面向对象思想答：物以类聚有，分类的思维模式，思考问题首先解决问题需要哪些分类，然后对这些分类进行......
  • 面向对象编程(四)
    面向对象编程(四)一、面向对象的魔法方法1.魔法方法简介在类中，有一些内置好的特定的方法，方法名是“__xx__”,在进行特定的操作时会被调用，这些方法被称为魔法方法，不需......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99