编程语言
首页 > 编程语言> > Day18：面向对象编程上篇（面向对象编程本质：以类的方法组织代码，以对象的组织（封装数据））

Day18：面向对象编程上篇（面向对象编程本质：以类的方法组织代码，以对象的组织（封装数据））

作者：互联网

# 面向对象编程

Java的核心思想就是OOP(面向对象编程)

1.初识面向对象

面向过程&面向对象

​ 属性+方法=类

面向过程思想

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

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

面向对象思想

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

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

就像学方法一样，自己写也可也，但是有人写好了我们可以直接拿来调用，这就是面向对象

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

什么是面向对象

面向对象编程（Object-Oriented Programming,OOP）

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

抽象（abstraot）：简化的意思，就是把某个东西简化成几个点

三大特性

​ 封装

​ 继承：子类继承父类

​ 多态：因为继承，所以有多态

封装就是第一题，第二题，或者语文卷子，数学卷子

继承就是直角三角形继承自三角形，前者是后者的子类

而继承必然导致多态，有直角三角形，就必然有非直角三角形等等

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

​ 从代码运行角度考虑是现有类后有对象。类是对象的模板

2.方法回顾和加深

方法的定义

​ 修饰符

​ 返回值类型

​ break和return的区别：break：跳出switch结素循环；return 结束循环

​ 方法名：注意规范 见名知意

​ 参数列表：参数类型，参数名…可变长参数

​ 异常抛出：疑问后面讲解

package com.oop;

import java.io.IOException;

//Demo01 类
public class demo01 {

    //main 方法
    public static void main(String[] args) {

    }

    /*
    修饰符 返回值类型 方法名（...参数）{
        //方法体
        return 放回值；
    }
     */
    public String sayHello(){
        return "hello world"
    }

    //void是空
    //return结束方法 返回值或空
    public void hello(){
        return;
    }

    //a，b形参
    public int max(int a,int b){
        return a>b ? a : b;//三元运算符
    }

    //数组下标越界：Arrayindexoutofbounds

    //异常抛出的方法才是完整的
    public void readFile(String file) throws IOException{

    }
}

方法的调用：调用

​ 静态方法

public class Student {
//静态方法
public static void say(){
    System.out.println("学生说话");
}
}

静态调用

public class Demo02 {

    public static void main(String[] args) {
        Student.say();//静态方法调用
    }
}

​ 非静态方法：避免了外部直接调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yxLQozY3-1645627593021)(D:\Javanotebooks\jietu\92.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9qyS3IoX-1645627593022)(D:\Javanotebooks\jietu\93.png)]

所以：静态方法和非静态方法之间并不能调用

形参和实参

​ 值传递和引用传递

​ this关键字

eg：对象A的名字叫张三，对象B的名字叫李狗蛋。对象的名字属性都有自己独一无二的值

由于static修饰的表示属于类，因此如果想访问类的方法或者变量，则可以直接通过类名.方法名（） / 类名.变量 进行访问

所谓动态和静态的方法，对于一个类来说，如果没有被static修饰的成员变量或成员方法，那么每实例一个新的对象（new），这些非static所修饰的类都属于对象

非静态的调用得先new

形参和实参

package com.oop;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数类型要相同
        int add = new Demo03().add(1, 5);
        System.out.println(add);
    }

    public int add(int a, int b){
        return a+b;
    }


}

值传递和引用传递

值传递：复制一份，引用传递：新建快捷方式

package com.oop;

public class Demo04 {
    public static void main(String[] args) {
        int a =1;
        System.out.println(a);//1

        Demo04.change(a);

        System.out.println(a);//1
    }

    //返回值 为空
    public static void change(int a){
        a=10;
    }

}

package com.oop;

//引用传递：对象，本质还是值传递

//对象，内存

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);//null

        //非同类非静态用对象调用
        Demo05.change(person);
        System.out.println(person);//子聿
    }

    public static void change(Person person){
        //Person是一个对象：指向的是 Person person = new Person();可以改变属性
        person.name = "子聿";
    }
}

//定义了一个Person类,有一个属性name,并不是内部类
class Person{
    String name;
}

this关键字：代表当前这个类或当前这个对象

类和对象的关系

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

​ 动物、植物、手机、电脑…

​ Person类、Pet类、Car类等、这些都是用来秒速/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实列

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

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

创建和初始化对象

​ 使用new关键字创建对象

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

package com.oop.demo02;

//学生类（一个类只存在属性和方法）
public class Student {
    //属性：字段
    String name;//NULL 默认
    int age;//NULL o

    //方法
    //学生类是学生的属性（姓名） 方法（能干什么）
    //创建的学生对象是一个具体的学生（有头有脸）
    public void study(){
        System.out.println(this.name+"在学习");//学生在学习，但是学生是变化的，所以用this来指代
    }


}

//person-->身高，体重等
//学程序好：对世界进行更好的建模！
//面向对象编程:以类的方式组织代码，以对象的组织封装数据

package com.oop.demo02;

//一个项目应该只存在一个main方法（总测试类）
public class Application {
    public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化之后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student student = new Student();
        Student xiaoming = new Student();
        Student xh = new Student();


        xiaoming.name ="小明";
        xiaoming.age = 18;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);


        xh.name ="小红";
        xh.age = 19;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
    }
}

构造器

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

​ 1.必须和类的名字相同

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

构造器必须要掌握

1.一旦定义了有参构造，无参就必须显示定义
2.用来初始化值

alt+insert：生成构造器

//一旦定义了有参构造，无参就必须显示定义

package com.oop.demo02;

//java--->class
public class Preson {

    //一个类即使什么都不写，他也会存在一个方法

    String name;
    String age;


    //无参构造器
    //实例化初始值
    //1.使用new关键字，本质是在构造器
    public Preson(){

    }

    //有参构造器
    //1.一旦定义了有参构造，无参就必须显示定义
    //2.用来初始化值
    public Preson(String name){
        //this.name代表的是参数传下来的name ，
        // 而后面的name是有参的name
        this.name = name;
    }
    //alt+insert生成构造器


}
/*
 public static void main(String[] args) {
       //new 实例化了一个对象
        Preson preson = new Preson();
        System.out.println(preson.name);

    }
 */

构造器：
1.和类名相同
2.没有返回值
作用：
new本质调用构造器
初始化对象的值
注意点
1.定义了有参构造之后想使用无参构造，显示的定义一个有参构造

3.对象的创建分析

4.面向对象的三大特征

5.抽象类和接口

6.内部类及OOP实战

lt+insert生成构造器

}
/*
public static void main(String[] args) {
//new 实例化了一个对象
Preson preson = new Preson();
System.out.println(preson.name);

}

*/


**构造器：**
**1.和类名相同**
**2.没有返回值**
**作用：**
**new本质调用构造器**
**初始化对象的值**
**注意点**
**1.定义了有参构造之后想使用无参构造，显示的定义一个有参构造**

标签：name,对象,void,封装数据,面向对象编程,new,Day18,public,String
来源： https://blog.csdn.net/h1776842314/article/details/123101280