Java面向对象编程OOP

最新推荐文章于 2024-08-02 13:56:36 发布

wh_in_silence

最新推荐文章于 2024-08-02 13:56:36 发布

阅读量106

点赞数

文章标签： java 面向对象编程类

本文链接：https://blog.csdn.net/wendy_gong/article/details/119063466

版权

Java面向对象OOP

OOP

Objects Oriented Programming

https://www.jianshu.com/p/7a5b0043b035

面向过程思想
- 步骤清晰简单，第一步做什么，第二部做什么…
- 面向过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
面向对象编程(Object-Oriented Programming,OOP)
面向对象编程的本质就是：以类的方式组织代码，以对象来组织(封装)数据
抽象
三大特性
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后又类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后又对象。类是对象的模板。

public class Demo01 {
    public static void main(String[] args) {
        Demo01.sayHello();
        System.out.println("==================");
        int b = sum(1,3,5,7);
        System.out.println(b);
    }
    /*
    修饰符  返回值类型  方法名
    方法体
    返回值
     */
    public static void sayHello(){
        System.out.println("Hello,World!");
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
    public static int sum(int... b){
        int sum = 0;
        for (int i : b) {
            sum+=i;
        }
        return sum;
    }
}

方法的定义

方法的调用

静态方法

非静态方法

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法  static,静态方法可通过类名直接调用
        Student.say();
        System.out.println("==============");
        //非静态方法需要实例化这个类 new
        //对象类型  对象名 = 对象值;
        Student student = new Student();
        student.sayHello();
        student.say();
        System.out.println("=======分割线========");
    }
    //静态方法与类一起加载
    public static  void a(){

    }
    //类实例化之后才存在
    public void b(){

    }
}

package com.oop.demo01;

public class Student {
    //静态方法
    public static void say(){
        System.out.println("你好呀！");
    }
        public void sayHello(){
            System.out.println("Hello!");
        }

}

形参和实参

值传递和引用传递

public class Demo03 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
        System.out.println("=======分割线=======");
        Demo03.ao(a);
        System.out.println(a);
    }
    public static void ao(int b){
        b =10;
    }
}

//引用传递，对象，本质还是值传递。Java内存
public class Demo04 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        System.out.println("=========分割线=======");
        Demo04.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        //person 是个类指向具体的人，Person person = new Person();
        person.name = "raylene";
    }
}
class Person{//public类只有一个，其他类可有多个
    String name;
    int age;
}

this关键字

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- 动物、植物、手机、电脑…
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体事物应该具备的特点和行为。
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。
类中构造器也成为构造方法，实在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
构造器必须要掌握。

package com.oop.demo02;
//学生类
public class Student {
    //属性：字段
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+" is studying.");
    }
}

package com.oop.demo02;
/*
一个项目应该只有一个main方法
 */
public class Application {
    public static void main(String[] args) {
        //类抽象的，我们需要将其实例化
        //类实例化后会返回一个自己的对象
        //student对象就是Student类的一个具体实例
        Student student = new Student();
        System.out.println(student.age);
        System.out.println(student.name);
        student.name = "tom";
        student.age = 3;
        student.study();
    }
}

隐式构造器

//构造器，一个类即使什么都不写，也会存在一个方法（构造器）
public class Person {
    //构造器，一个类即使什么都不写，也会存在一个方法（构造器）
    //显示地定义构造器
    String name;
}

public class Person {
    String name;

    public Person() {
    }
}

无参构造器

public class Person {
    //构造器，一个类即使什么都不写，也会存在一个方法（构造器）
    //显示地定义构造器
    String name;

    public Person() {
        this.name = "JERRY";
    }
}

public class Application {
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);
        
    }
}

有参构造器

public class Person {
    //构造器，一个类即使什么都不写，也会存在一个方法（构造器）
    //显示地定义构造器
    String name;

    public Person(String name) {
        this.name = name;
    }
}

public class Application {
    public static void main(String[] args) {
/*
        Person person = new Person();
        System.out.println(person.name);
        */
        Person person1 = new Person("JERRY");
        System.out.println(person1.name);

    }
}

无参构造器与有参构造器同时存在(即方法的重载)

public class Person {
    //构造器，一个类即使什么都不写，也会存在一个方法（构造器）
    //显示地定义构造器
    String name;
    public Person(){
        name = "JERRY";
    }

    public Person(String name) {
        this.name = name;
    }
}

public class Application {
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);

        Person person1 = new Person("JERRY");
        System.out.println(person1.name);

    }
}

构造器总结

构造器定义：

和类名相同
没有返回值

作用：

new的本质是在调用构造方法
初始化对象的值

注意点：

定义有参构造方法之后，如果想使用无参构造，显式地定义一个无参的构造方法

快捷键：

Alt+Insert

this关键字

创建对象内存分析

public class Pet {
    public String name;
    public int age;
    public void shout(){
        System.out.println("汪汪，汪汪汪！");
    }

}

import com.oop.demo03.Pet;

public class Application {
    public static void main(String[] args) {
        Pet pet = new Pet();
        pet.name = "旺财";
        pet.age = 3;
        pet.shout();
        System.out.println(pet.name + "今年" + pet.age+"岁了！");
    }
}