面向对象

面向对象

Java

发布日期: 2023-08-14

更新日期: 2023-08-12

文章字数: 2.1k

阅读时长: 8 分

阅读次数:

1. 类和对象

类是对事物的一种描述，对象则为具体存在的事物

1.1 类的定义

类的组成是由属性和行为两部分组成

属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

定义类
编写类的成员变量
编写类的成员方法

类包含属性和方法（使用class关键字定义）

class className {
    属性；
    方法；  
}

类可以分为类名和类体

// 定义了一个Person的类
public class Person {
  private int age; // 全局变量
  private String name;

  // 定义了一个say的方法
  public void say() {
    System.out.println("定义方法");
  }
}

1.2 对象创建和使用

创建对象格式：

类名 对象名 = new 类名();

调用成员的格式：

对象名.成员变量
对象名.成员方法();

类名的首字母大写
变量名和方法名的首字母小写

示例代码：

/*
    创建对象
        格式：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

1.3 对象的内存图

1.3.1 单个对象内存图

成员变量使用过程

成员方法调用过程

1.3.2 多个对象内存图

成员变量使用过程

成员方法调用过程

总结：

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

1.4 成员变量和局部变量

1.4.1变量的分类

局部变量
成员变量（全局变量）
类变量（用static修饰的变量）
实例变量（没有static修饰的变量）

类变量：用关键字static定义，调用时使用 类名.变量名 访问

public class one {
    static int age = 18; // 静态变量

    public static void main(String[] args) {

        System.out.println(one.age);
    }
}

// 输出结果为： 18

实例变量：与类的实例对应。当实例被创建时，分配内存空间；当实例销毁时，内存空间回收。

  public class Student {
    public static int amount = 10;//静态
        public int age = 24;//实例
}
public class Student {
    public static int a = 20; // 静态变量
    //public int age = 22； // 实例变量
  // 定义的一个方法
    public void get_stu() {
        int a = 18;
        System.out.println("我现在的年龄为" + a);
    }

 // 主方法
    public static void main(String[] args) {
        Student gn = new Student();  // 这里要new一个对象gn来接受值
        gn.get_stu();

    }
}

// >> 我现在的年龄为18

package com.pragect;

public class two {
    private static int sid = 0;
    private String name;

    int id;
    two(String name) {
        id = sid ++;
        this.name = "hhh";
    }

    public void inof() {
        System.out.println("My name is " + name + ", Num is :" + id );
    }

    public static void main(String[] args) {
        two.sid = 30;
        two mm = new two("mm");
        two pp = new two("pp");
        mm.inof();
        pp.inof();

    }
}
// >> My name is hhh, Num is :30
// >> My name is hhh, Num is :31

1.4.2 成员变量和局部变量的区别

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

2. 面向对象

20世纪80年底后期，人们提出了面向对象(Object Oriented Programming，OOP)的设计思路。面向对象的程序是由对象组成的，每个对象含有对用户公开的部分和私有的隐藏部分，将数据和处理数据的方法结合起来，形成类；再将类实例化，形成对象。面向对象不需要程序员考虑数据结构和函数功能，只关注对象。

面向过程：

将事物的发展划分为若干个块，以函数实现，最后将这些块进行调用和连接。
缺点：当客户需求不断增加，软件规模越来越大，开发周期长，难以维护。

2.1 面向对象的基本特征

封装性

把对象的全部属性和方法结合在一起，形成不可分割的整体，当与外部发生作用时，依靠接口实现

继承性

特殊类可以拥有一般类的属性和方法，称为继承。被继承的类称为父类，继承的类称为子类

多态性

父类的属性和方法被继承后，可以有不同的表现形式

3. This关键字

this关键字是java中的一个关键字，表示某个对象（不可以出现在类方法中）

package com.pragect;

public class three {
        int leg, hand;
        String name;

       // this关键字在类中的用法（我认为相当于C语言中的结构体）
        three (String s) {
            this.name = s;
            this.init();
        }

        public void init() {
            leg = 2;
            hand = 2;
            System.out.println("我的名字叫" + name + ", 我有" + hand + "只手, " + leg + "只脚");
        }

    public static void main(String[] args) {
        new three("Tom");
    }

}
 // >> 我的名字叫Tom, 我有2只手, 2只脚
package com.pragect;

public class Student {
    static String words = " ##全局变量## ";
    public void getStu() {
        String words = " **局部变量** ";
        System.out.println("words的局部变量是" + words);
        System.out.println("访问的全局变量是" + this.words);
    }

    public static void main(String[] args) {
        Student stu = new Student();
        stu.getStu();
    }
}

// >> words的局部变量是 **局部变量** 
// >> 访问的全局变量是 ##全局变量##

4. package

package语句作为Java源文件的第一条语句，为该源文件中声明的类指定包名。
通过关键字package声明包语句。


package语句的一般格式为：
package 包名;

import语句

一个类可能需要另一个类声明的对象作为自己的成员或方法中的局部变量，如果这两个类在同一个包中，当然没有问题如果一个类想要使用的那个类和它不在一个包中，要使用import语句完成使命。引入的包，可以是系统自带的，也可以是自定义的。

public修饰符

•用public修饰的变量和方法称为“共有变量”和“共有方法”，当我们在任何一个类中创建一个对象后，该对象可以访问自己的public变量和类中的public方法，也可以通过继承的方式来操作成员变量和方法．

private修饰符

用关键字private修饰的变量或方法称为“私有变量”或“私有方法”，只在本类中起作用，在其他类中无法正常识别.

protected修饰符

们定义一个父类，其中有protected类型的变量或方法，此时我们又定义了一个子类，不管父类和子类是否在同一个包中，子类对象可以任意调用父类中的protected类型的内容。

default修饰符

default类型称为友好的，也称为默认的，就是变量的数据类型前面什么修饰符都不添加．有以下特性。如果我们定义一个父类，其中有default类型的变量或方法，此时我们又定义了一个子类，则只有当父类和子类在同一个包中，子类对象才可以访问父类中的default变量。

香辣小猪

https://spicypig.top/2023/08/14/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源香辣小猪 !

面向对象

2023-08-18 苦逼小码农

Git

2023-08-01 TOOL

Git

1. 类和对象

1.1 类的定义

1.2 对象创建和使用

1.3 对象的内存图

1.3.1 单个对象内存图

1.3.2 多个对象内存图

1.4 成员变量和局部变量

1.4.1变量的分类

1.4.2 成员变量和局部变量的区别

2. 面向对象

2.1 面向对象的基本特征

3. This关键字

4. package

你的赏识是我前进的动力