面向对象（类与对象）

今天你改bug了吗？

已于 2023-12-05 15:51:41 修改

阅读量24

点赞数

分类专栏： JavaSE 文章标签： java 服务器前端

于 2023-10-27 14:22:02 首次发布

本文链接：https://blog.csdn.net/m0_57331274/article/details/134043181

版权

JavaSE 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

举例：

洗衣服：

面向过程：把衣服脱下来-->找一个盆-->放洗衣粉-->加水-->浸泡10分钟-->清洗衣服-->拧干-->晾晒
面向对象：把衣服脱下来-->放进洗衣机设置好-->晾衣服

特点：

面向对象思想是一种更符合思考习惯的思想，可以将复杂的事情简单化，并将我们从执行者变成指挥者。

面向对象的语言中，包含三大基本特征，即封装、继承、多态。

1 类

1.1 定义

是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：

属性：就是该事物的状态信息。
行为：就是该事物能够做什么。

举例：小猫

属性：名字、体重、年龄、颜色。
行为：走、跑、叫。

1.2 定义格式

public class 类的名称{

//成员变量

//成员方法

}

定义类：就是定义类的成员，包括成员变量和成员方法。
成员变量：和以前定义变量几乎是一样的，只不过位置发生了改变。在类中，方法外。
成员方法：和以前定义方法几乎是一样的，只不过把static去掉。

public class Day5_lei {
    //成员变量
    String name;
    int age;
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }//吃饭
    public void sleep(){
        System.out.println("睡觉");
    }//睡觉
    public void study(){
        System.out.println("学习");
    }//学习

    public static void main(String[] args) {
     

    }
}

一个标准的类通常要满足下面四个组成部分：

所有成员变量都要使用private关键字修饰
为每一个成员变量编写一个Getter/Setter方法
编写一个无参数的构造方法
编写一个全参数的构造方法

这样的类也叫做Java Bean。

public class Day6_biaozhunlei_student {
    //成员变量
    private String name;
    private int age;
    private double chengji;

    //Getter/Setter方法
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age){
        if (age>=0){
            this.age=age;
        }else {
            System.out.println("年龄格式有错误");
        }

    }
    public int getAge(){
        return age;
    }

    public void setChengji(double chengji){
        if (chengji>=0){
            this.chengji=chengji;
        }else {
            System.out.println("成绩格式有错误");
        }

    }
    public double getChengji(){
        return chengji;
    }

    //构造方法

    public Day6_biaozhunlei_student() {
    }

    public Day6_biaozhunlei_student(String name, int age, double chengji) {
        this.name = name;
        this.age = age;
        this.chengji = chengji;
    }
}

public class Day6_biaozhunlei {
    public static void main(String[] args) {
        Day6_biaozhunlei_student stu1=new Day6_biaozhunlei_student();
        stu1.setName("王五");
        stu1.setAge(-20);
        stu1.setChengji(123);
        System.out.println("姓名是"+stu1.getName()+"年龄"+stu1.getAge()+"成绩是"+stu1.getChengji());

        System.out.println("-------");

        Day6_biaozhunlei_student stu2=new Day6_biaozhunlei_student("李四",21,234);
        System.out.println("姓名是"+stu2.getName()+"年龄"+stu2.getAge()+"成绩是"+stu2.getChengji());
        stu2.setAge(34);
        System.out.println("姓名是"+stu2.getName()+"年龄"+stu2.getAge()+"成绩是"+stu2.getChengji());
    }
}

1.3 static关键字

1.3.1 静态static关键字修饰成员变量

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

public class Student {
    private int id;
    private String name;
    private int age;
    static String room;

    public static int idCounter=0;//学号计数器，每当new了一个新对象，计数器+1
        


    public Student() {
        this.id=++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id=++idCounter;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

public class Day7_static {
    public static void main(String[] args) {
        Student stu1=new Student("aaa",16);
        stu1.room="101教室";
        Student stu2=new Student("bbb",17);
        System.out.println("id是"+stu1.getId()+"姓名是"+stu1.getName()+"年龄是"+stu1.getAge()+"教室是"+stu1.room);
        System.out.println("id是"+stu1.getId()+"姓名是"+stu2.getName()+"年龄是"+stu2.getAge()+"教室是"+stu2.room);
    }
}

1.3.2 静态static关键字修饰成员方法

一旦使用static关键字修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

public class MyClass {
    int num;//成员变量
    static int numStatic;//静态变量

    public void method(){
        System.out.println("这是一个成员方法");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
        //静态方法不可以访问成员变量，即静态不能直接访问非静态
//        System.out.println(num);
        //静态方法可以访问静态变量
        System.out.println(numStatic);
        //静态方法中不能使用this关键字
//        System.out.println(this);
    }
}

public class Day7_static2 {
    public static void main(String[] args) {
        MyClass obj=new MyClass();
        obj.method();

        //对于静态方法，可以通过对象名调用，也可以直接通过类名称调用
        obj.methodStatic();//正确，不推荐，这种方法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic();//正确，推荐

        //对于本类当中的静态方法，可以省略类名称
        myMethod();
        Day7_static2.myMethod();
    }
    public static void myMethod(){
        System.out.println("自己的方法");
    }
}

1.3.3 注意事项

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。

静态变量：类名称.静态变量；
静态方法：类名称.静态方法（）；

注：

1.静态不能直接访问非静态。

原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容

2.静态方法当中不能用this。

原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

1.3.4 静态代码块

（1）格式

public class 类名称{

static{

//静态代码块的内容

}

public class Person {
    static{
        System.out.println("静态代码块执行");
    }

    public Person() {
        System.out.println("构造方法执行");
    }
}

public class Day7_static3 {
    public static void main(String[] args) {
        Person per=new Person();
        Person per2=new Person();
    }
}

输出：静态代码块执行
构造方法执行
构造方法执行

（2）特点

当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

（3）典型用途

用来一次性的对静态成员变量进行赋值。

1.3.5 内存图

2 对象

2.1 定义

是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。

现实中，一类事物的一个实例：一只小猫。

2.2 使用格式

1. 导包：指出需要使用的类在什么位置。

import 包名称.类名称

对于和当前类属于同一个包的情况，可以省略导包语句不写

2. 创建

类名称对象名 =new 类名称（）；

3. 使用，分为两种情况

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）

（即，想用谁，就用对象名.谁）

//调用
public class Day5_person {
    public static void main(String[] args) {
        //创建对象
        Day5_phone phone=new Day5_phone();

        phone.brand="华为";
        phone.price=4515.54;
        phone.color="白色";
        System.out.println(phone.brand);
        System.out.println(phone.price);
        System.out.println(phone.color);

        phone.call("李四");
        phone.sendMessage();

    }
}

//定义
public class Day5_phone {
    //成员变量
    String brand;
    double price;
    private double price2;
    String color;

    //成员方法
    public void call(String who){
        System.out.println("给"+who+"打电话");
    }//打电话
    public void sendMessage(){
        System.out.println("群发短信");
    }//发短信

    
}

注意事项：

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

2.3 匿名对象

创建对象的标准格式：

类名称对象名 = new 类名称（）；

创建匿名对象的格式：

就是只有右边的对象，没有左边的名字和赋值运算符

new 类名称（）；

public class Day6_anonymous {
    public static void main(String[] args) {
        //左边的one就是对象的名字
        Day6_person one=new Day6_person();
        one.name="张三";
        one.sayHello("王思聪");

        //匿名对象
        new Day6_person().name="赵又廷";
        new Day6_person().sayHello("cici");
    }

}

import java.util.Scanner;

public class Day6_anonymous2 {
    public static void main(String[] args) {
        //普通使用方式
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();

        //匿名对象使用方式
        int num2=new Scanner(System.in).nextInt();
        System.out.println("输入的是"+num2);

        //匿名对象作为方法的参数
        methodParam(new Scanner(System.in));

        //匿名对象作为方法返回值
        System.out.println("输出的是"+methodParam2().nextInt());
    }

    public static void methodParam(Scanner sc){
        System.out.println(sc);
        int num=sc.nextInt();
        System.out.println("输入的是"+num);
    }

    public static Scanner methodParam2(){
        return new Scanner(System.in);
    }
}

注意事项：

匿名对象只能使用为一个一次，下次再用不得不再创建一个新对象。

使用建议：

如果确定有一个对象只需要使用唯一一次，那么可以用匿名对象。

3 类与对象

3.1 类与对象的关系

类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实体。

3.2 事物与类的对比

现实世界的一类事物：

属性：事物的状态信息。

行为：事物能够做什么。

Java中用class描述事物也是如此：

成员变量：对应事物的属性。

成员方法：对应事物的行为。

3.3 内存图

1. 一个对象的内存图

2. 两个对象使用同一个方法的内存图

3. 两个引用指向同一个对象的内存图

4. 使用对象类型作为方法的参数

5. 使用对象类型作为方法的返回值

3.4 局部变量和成员变量区分

1.定义的位置不一样【重点】：

局部变量：在方法内部

成员变量：在方法外部，直接写在类中

2.作用范围不一样【重点】：

局部变量：只有方法当中才可以使用，出了方法就不能再用

成员变量：整个类都可以使用

3.默认值不一样【重点】：

局部变量：没有默认值，如果想要使用，必须手动进行赋值

成员变量：如果没有赋值，会有默认值，规则和数组一样

4.内存的位置不一样（了解）：

局部变量：位于栈内存

成员变量：位于堆内存

5.生命周期不一样（了解）：

局部变量：随着方法进栈而诞生，随着方法出栈而消失

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

今天你改bug了吗？

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
面向对象（类与对象）

是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。属性：就是该事物的状态信息。行为：就是该事物能够做什么。举例：小猫属性：名字、体重、年龄、颜色。行为：走、跑、叫。public class 类的名称{//成员变量//成员方法就是定义类的成员，包括成员变量和成员方法。和以前定义变量几乎是一样的，只不过位置发生了改变。在类中，方法外。和以前定义方法几乎是一样的，只不过把static去掉。//成员变量int age;//成员方法。
复制链接

扫一扫