面向对象（上）

励志成小牛

已于 2023-01-27 00:45:44 修改

阅读量71

点赞数 1

文章标签： java 开发语言

于 2023-01-27 00:42:26 首次发布

本文链接：https://blog.csdn.net/weixin_46973700/article/details/128768719

版权

面向对象（Object-Oriented Programming，OOP）：

什么是面向对象：从面向过程思想和面向对象思想来说：

面向过程思想：

步骤清晰简单，第一步做什么、第二步做什么
面向过程适合处理一些较为简单的问题

面向对象思想：

物理类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后对某个分类下的细节进行面向过程的思索
面向对象适合处理复杂的问题，适合处理需要多人协作的问题
重点：以类的方式组织代码，以对象的组织封装数据

三大特点：

封装
继承
多态

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

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

方法的回顾以及调用：

break：跳出switch结束循环

return：结束方法返回结果

方法的调用：递归

在一个类中调用其他类的方法的过程(分为静态方法和非静态方法)：

首先是调用静态方法（有static关键字）

写了一个Demo10类，想要在这个类中调用Student类中的静态方法

package com.liyan;
public class Demo10 {
    public static void main(String[] args) {
        //静态方法：有关键字：static
        Student.say();//调用其他类中的静态方法：类名.方法名;
    }//输出结果为：学生说话了
}

又写了一个Student类，在类中写了一个静态方法来被调用

package com.liyan;
//学生类
public class Student {
    //静态方法，有关键字static
    public static void say() {
        System.out.println("学生说话了");
    }
}

其次是调用非静态方法（没有static关键字）

写了一个Demo10类，想要在这个类中调用Student类中的非静态方法

package com.liyan;

public class Demo10 {
    public static void main(String[] args) {
        //非静态方法：没有static关键字
        //调用其他类中非静态方法：前面加个new
        //1.实例化这个类 new
        //2.对象类型 对象名 = 对象值
        Student student = new Student();
        student.says();
    }
}

2.又写了一个Student类，在类中写了一个非静态方法来被调用

package com.liyan;
//学生类
public class Student {
    //非静态方法
    public void says(){//没有static关键字
        System.out.println("学生说话了");
    }
}

说一个比较特殊的情况：加入在一个类中方法想要调用另一个方法

package com.liyan;

//学生类
public class Student {
	//静态方法
    public static void a(){
        b();//这样写是没有问题的，两个都是静态方法
    }
    //静态方法
    public static void b(){
       
    }
}

package com.liyan;

//学生类
public class Student {
	//静态方法
    public static void a(){
        b();//这样写是有问题的，是会报错的，b是非静态方法
    }
    //非静态方法
    public  void b(){
       
    }
}

报错原因：因为静态方法是和类一起加载的，非静态方法是通过类实例化之后才存在的，一个存在的调用一个不存在的就会报错

值传递和引用传递

值传递：

//值传递
package com.liyan;

//学生类
public class Student {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//输出结果为1
        Student.add(a);
        System.out.println(a);//输出结果为1
    }

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

引用传递：

package com.liyan;

//学生类
public class Student {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        Student.change(person);
        System.out.println(person.name);//liyan
    }
    public static void change(Person person){
        //person是一个对象，指向的-->Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "liyan";
    }
}

//定义了一个Person类，有一个属性：name
class Person{
    String name;
}

类与对象的关系

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

动物、植物、手机…
Person类、Pet类、Car类…

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

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

创建与初始化对象：

package com.xuexi;
//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name + "在学习");//this代表当前的这个类
    }
}
//这个类相当于抽象的模板

使用new关键字创建对象

package com.xuexi;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

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

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

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

        xiaohong.name = "小红";
        xiaohong.age = 3;

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

总结：写了第一个Student类，相当于一个空白模板，只是定义了一下，没有赋任何值，全部为初始值，如果想给他赋值，必须在学生类中加一个构造器或者在Application类中初始化值

构造器详解

有了这个东西，相当于你可以在向上面的例子中，在Student类中初始化一个值并且在主函数中拿来用

构造器特点：1.必须和类名相同 2.无返回类型，不能写void

举个例子：

首先，写了一个Person类，然后写了一个有参构造器和一个无参构造器：

package com.xuexi;

public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;

    public Person() {
    }//无参构造器，括号中无参数

    public Person(String name) {
        this.name = name;
    }//有参构造器
}

其次，加入要在Application类中调用Person中的方法，如下：

package com.xuexi;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
    
        Person person = new Person();//因为括号中无参数，调用的是Person类中的无参构造器
        //注意这里，如果Person类中没有写无参构造，那么这句话就会报错
        
        Person person = new Person("liyan");//因为括号中有参数，调用的是Person类中有参构造器
        
        System.out.println(person.name);//表示调用的是Person类中的有参构造器，因为有参数
    }
}

总结：