面对对象（类与对象）_为什么叫做面对对象-CSDN博客

本文链接：https://blog.csdn.net/qq_53551331/article/details/126736181

面向对象思想介绍

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

面向对象思想总结:
1.面向过程:当要实现一个功能时,需要亲力亲为,处理每个细节
2.面向对象:当要实现一个功能时,不关心具体的实现步骤,只关心结果,找一个具有该功能的类,帮我们做事
3.面向对象的思想
(1)面向对象是基于面向过程的编程思想.
(2)面向过程:强调的是每一个功能的步骤
(3)面向对象:强调的是对象,然后由对象去调用功能
4.特点
(1)是一种更符合我们思考习惯的思想
(2)可以将复杂的事情简单化
(3)角色发生了转换,将我们从执行者变成了指挥者

什么是面对过程，什么是面对对象？

面对过程：指的所有步骤都得亲力亲为才能完成某件事。

面对对象：将世间万物看成一个个对象，通过调用对象的属性和方法来完成事情。

面对对象的两大核心概念——类与对象

万物皆对象

类

类是抽象的，是一组事物的集合体。

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

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

对象

对象是类的具体体现，一般唯一的东西一定是对象。

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。

类与对象是相对的关系。

Java中的类与对象

通过分析我们发现，世间万物皆可以通过两个方面去描述它，分别是属性特征和行为/动作/功能。

类的定义

语法：

访问权限修饰符 class 类名 {
//成员变量属性特征
//成员方法行为特性
}

说明：

定义类：就是对业务或者现实中的某一实实在在的分类物以Java语言中的类进行定义并分类管理，参考现实类有属性和行为两个关键特征，所以Java中的类也包括属性和行为。
访问权限修饰符：就是Java中控制当前类是否可见，被谁可见的关键字，包括有public、protected、default 、private（具体功能后续会进行说明），通常类的权限修饰符都为public。
class：定义Java类的关键字。
类名：就是我们要创建具体的什么类，给取个见名知意名字。比如，学生类Student、老师类Teacher等。
成员变量：和以前定义变量几乎是一样的（可以类比现实对象的属性）。只不过位置发生了改变。在类中，方法外。
成员方法：可以类比显示对象的行为动作，描述了此类的所有对象可以有什么行为，以及怎么行动（之前的main()方法就是一个例子）。

实例：

public class Student {
  	// 成员变量
  	String username;//姓名
    int age; //年龄

    //成员方法
    //学习的方法
    public static void study() {
       System.out.println("好好学习，天天向上");
    }
    // 跑步的方法
    public void run(String username,int distance) {
       System.out.println(username+" 今天跑了"+distance+"m");
    }
}

对象的创建

Java类有了，但还只是一个抽象的概念的东西，如果要使用，必须创造出一个个具体的对象。

语法：

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

使用对象访问类中的成员:

对象名.成员变量；

对象名.成员方法()；

示例：

public class StudentTest {
  public static void main(String[] args) {
    // 创建对象格式：类名 对象名 = new 类名();
    Student s = new Student();
    System.out.println(s); //com.hopu.classobject.Student@15db9742
  }	
}

对象的创建及基本使用：

public class StudentTest {
	  public static void main(String[] args) {
	    // 创建对象格式：类名 对象名 = new 类名();
	    Student s = new Student();
	    System.out.println(s); //com.hopu.classobject.Student@15db9742

	    // 直接输出成员变量值
	    System.out.println("姓名："+s.username); //null
	    System.out.println("年龄："+s.age); //0
	    System.out.println("----------");

	    //给成员变量赋值
	    s.username = "佐佐木希";
	    s.age = 32;

	    // 再次输出成员变量的值
	    System.out.println("姓名："+s.username); //佐佐木希
	    System.out.println("年龄："+s.age); //32
	    System.out.println("----------");

	    // 调用成员方法
	    s.study(); // "好好学习，天天向上"
	    s.run("tom",123); // 跑步
	  }	
}

从上面的示例结果可以看出，对象创建后直接输出对象的成员变量没有报错，有一些默认初始化值。具体见如下表，这个与之前讲解的数组的默认初始化值是一样的。

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	'\u0000'
	布尔（boolean）	false
引用类型	数组，类，接口	null

类与对象实例

定义手机类：

public class Phone {
  // 成员变量
  String brand; //品牌
  int price; //价格
  String color; //颜色

  // 成员方法
  //打电话
  public void call(String name) {
    System.out.println("给"+name+"打电话");
  }

  //发短信
  public void sendMessage() {
    System.out.println("群发短信");
  }
}

定义测试类：

public class PhoneTest {
  public static void main(String[] args) {
    //创建对象
    Phone p = new Phone();

    //输出成员变量值
    System.out.println("品牌："+p.brand);//null
    System.out.println("价格："+p.price);//0
    System.out.println("颜色："+p.color);//null
    System.out.println("------------");

    //给成员变量赋值
    p.brand = "锤子";
    p.price = 2999;
    p.color = "棕色";

    //再次输出成员变量值
    System.out.println("品牌："+p.brand);//锤子
    System.out.println("价格："+p.price);//2999
    System.out.println("颜色："+p.color);//棕色
    System.out.println("------------");

    //调用成员方法
    p.call("紫霞");
    p.sendMessage();
  }
}

成员变量与局部变量

在前面介绍类的定义时，介绍了Java类中包括有成员变量与方法两个核心部分。而Java中变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：

成员变量与局部变量区别（考点）

初始值不同
- 局部变量没有初始值，必须先赋值后使用
- 成员变量有初始值，可以不必赋值就能直接使用
在类中的位置不同
- 局部变量指的是在方法中定义的变量
- 成员变量指的是在类中方法外的变量
作用范围不同
- 局部变量只能作用在方法中
- 成员变量作用在整个类中
在内存中的位置不同
- 局部变量在栈空间分配
- 成员变量在堆/方法区分配
生命周期不同
- 局部变量生命周期随方法诞生而诞生，随方法结束而结束
- 成员变量随对象/类的诞生而诞生，随对象/类的结束而结束

方法

什么是方法

方法就是一段代码的集合体

为什么要使用方法

减少代码的多余，提高复用

方法的定义

权限修饰符 [静态修饰符] 返回值 方法名([参数列表]){
    
}

说明：

访问权限修饰符： 与之前类定义时使用的权限修饰符类似，指定方法的可用范围。
静态修饰符：定义了该方法可以被如何访问，其关键字为static（静态的意思）。如果方法前有static关键字，不用创建类对象直接使用类就可以直接访问；如果没有static关键字，必须创建出具体的对象，使用对象才能访问该方法。
返回值类型： 方法执行完成后的返回结果类型。如果方法没有返回值，使用 void关键字即可；如果有返回值，要根据返回值的类型来确定，是什么返回值类型就用什么类型。
方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
参数类型： 定义的方法可能需要传递一个动态的数据，可以用方法参数进行接收。其中，参数类型表示限定了当前方法允许接收的参数类型。
参数名：与参数类型是一一对应的，用来接收调用方法时传递的参数值。参数类型与参数名统称为参数列表，多个参数列表直接可以用逗号“，”分隔。
执行代码：就是一个方法里面具体干的事。
return：方法中的执行代码执行后要返回的结果。如果有返回值，就用“return 返回的结果”来表示；如果没有要返回的结果，可以直接用一个return关键字即可，甚至可以省略。

实例：

public class MethodTest {
	//1、普通无参、无返回值方法
	public void print() {
		System.out.println("这是一个普通的无参、无返回值方法");
		return;  // 无返回值方法，return关键字可以省略
	}
	// 2、普通有参、无返回值方法
	public void printSum(int a,int b) {
		int sum=a+b;
		System.out.println(a+"与"+"b的和为："+sum);
	}
	// 3、普通有参数、有返回值的方法
	public int getMax(int a,int b) {
		int max=a>b ? a : b;
		return max;
	}
	// 4、静态有参数、有返回值的方法
	public int getAbs(int a) {
		if(a<0) {
			return -a;
		}else {
			return a;
		}
	}
}

方法不能嵌套定义

方法只能定义在类中，不支持在方法中再嵌套定义方法。

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

    }
    public static void methodOne() {
        public static void methodTwo() {
            // 这里会引发编译错误!!!
        }
    }
}

返回值类型，必须要和return语句返回的类型相同或者比返回值类型范围小，否则编译失败。

// 返回值类型要求是int
public static int getSum() {
    return 5;// 正确，int类型
    return 1.2;// 错误，类型不匹配
    return true;// 错误，类型不匹配
}

不能在return 后面写代码，return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。

public static int getSum(int a,int b) {
    return a + b;
    System.out.println("Hello World");// 错误，return已经结束，这里不会执行，无效代码
}

void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

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

    }
    public static void methodTwo() {
        return;  // 也可以省略return，后续不能编写其他代码
    }
}

main()方法详解

在Java中，main()方法是Java应用程序的入口方法，也就是说，程序在运行的时候，第一个执行的方法就是main()方法，这个方法和其他的方法有很大的不同，比如方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数等等。

main方法的定义格式通常固定如下：

public class Demo {
	public static void main(String[] args) {
		System.out.println("Hello Word");
	}
}

图解：

说明：

为什么是公共的（public）

Java设计了几个访问修饰符，包括：private、default 、protected、public。在Java中声明为public的任何方法或变量都可以从该类的外部访问。而JVM访问main方法显然不是在类的内部访问，因此main方法需要定义为public的方法。
为什么是静态的（static）

静态可以让JVM调用main方法的时候更加方便，不需要通过对象调用。关于static关键字我们知道的是，static关键字修饰的方法，可以不用通过创建一个实例去访问，而是可以通过类名直接访问。并且static修饰的方法以及变量存储在虚拟机当中的方法区当中，而非堆内存当中。那么，对于虚拟机来说也是一样的道理。main方法定义为static的，则对于虚拟机来说，在程序启动之后并不需要创建一个实例，就可以去调用这个main方法。
为什么没有返回值（void）

void表示main方法没有返回值，没有返回值的原因是因为Java不需要main方法向操作系统返回退出信息。如果main方法正常退出，那么Java应用层序的退出代码为0，表示成功的运行了程序。
main

main的名称不能变是为了JVM能够识别程序运行的起点，main方法可以被重载，重载的main方法不会被执行。main方法作为程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程，非守护线程和守护线程，main方法属于非守护线程，守护线程通常由JVM自己使用，Java程序也可以表明自己的线程是守护线程。当程序中所有的非守护线程终止时，JVM退出。也可以用Runtime类或者System.exit()来退出。
String [] args

String[] args,是main方法中唯一可以改变的地方！args是arguments的缩写，只是一个变量默认名，习惯性写作它，但是也可以改变的，只要符合命名规则随便你写成什么。在使用集成开发工具的今天，String[] args更像是一种摆设了，很多初学者都不知道它的作用，其实它是程序运行传入的一个参数组。

方法重载

Java方法重载的概念

指在同一个类中，允许存在一个以上的同名方法，只要他们的参数列表不同即可，与修饰符和返回值类型无关。

实例：

在一个类中定义三个方法，一个方法接收2个int类型的参数并返回求和结果；一个方法接收2个double类型并直接打印求和结果；一个方法接收3个int类型的参数并返回求和结果。

public class MethodOverloadTest {
	// 1、2个int类型参数的方法求和
	public int getSum(int a,int b) {
		return a+b;
	}
	// 2、2个double类型参数的方法求和
	public void getSum(double a,double b) {
		System.out.println(a+b);
	}
	// 2、3个int类型参数的方法求和
	public int getSum(int a,int b,int c) {
		return a+b+c;
	}
}