本文共 7170 字，大约阅读时间需要 23 分钟。

面向对象是Java语言的最基本结构，要学会Java必须要搞懂面向对象

第三周：面向对象

一、面向对象

了解面向对象之前先了解面向过程：

//面向过程的经典代表：C语言；

面向过程：

那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

假如我们要求数组中的最大值：

首先：定义一个数组-->>然后：静态初始化-->>然后：定义一个参照物-->>遍历

这整个过程：从需求分析-->>到一步步操作-->>最终得到结果-->>都是自己在完成

面向对象思想引入：

前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。

面向对象思想概述：

面向对象是基于面向过程的编程思想。

面向对象的思想特点:

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

1.面向对象更符合我们生活中的行为思想习惯。

2.面向对象将我们从执行者变成了指挥者，指挥对象做事情。

3.面向对象简单性体现在这里：让我们做事情从复杂性-->简单化。

面向对象思想举例：

洗衣服：

面向过程的做法：

脱下脏衣服-->放到一个盆里面-->加水,洗衣液-->泡一泡-->搓一搓-->拧一拧-->晾一晾

面向对象的做法：

脱下脏衣服-->放到一个全自动洗衣机中-->一键洗衣-->晾一晾

整个过程中，面向对象就相当于做了一台全自动洗衣机，当我们需要洗衣服的时候只需要去调用洗衣机就可以了。

面向对象开发就是不断地创建对象，使用对象、指挥对象做事情！

面向对象设计其实就是在管理和维护对象之间的关系！

面向对象特征：封装、继承、多态

简单了解面向对象之后就要开始详细学习了，首先了解‘类和对象’ 的关系

二、类和对象的关系

比如超市的计费系统、银行办理业务的系统等等；

如何描述一个现实世界的事物？

属性和行为!

    属性就是该事物的描述信息，例如：这是一个什么样的事物、有哪些特点

    行为就是该事物能干什么

Java语言最基本的单位就是类，所以我们就把事物比作一个对象，类作为这个对象的模板

对象：对象是类的实例，有状态和行为。        //是以类为模型创建的具体实例，是对类的一种具体化

类：类是一个模板，它描述一类对象的行为和状态        //可以理解为构造对象的一个蓝图或者模板，是抽象的概念

三、

1.定义类和成员变量、成员方法

将一个事物用编程的思想的形式体现出来

定义一个手机类：

/** * 例如： * 一个手机类：Phone * 属性：品牌、颜色、价格				成员变量 * 行为：打电话、发短信、玩游戏			成员方法 * *///创建一个手机类public class Phone{		//定义（手机的属性）成员变量		String 	pinpai;		String	color;		int		price;		//定义（手机的行为）成员方法		public int callNumber(int a) {	//方法里面定义的变量叫做局部变量			int num=10086;			return a=num;		}		public void send() {			System.out.println("手机可以发短信");		}		public void play() {			System.out.println("手机可以玩游戏");		}}

一个类中可以有的类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

2.使用对象

定义完了一个类，就要学会使用这个类和类中的对象。

在测试类main方法中调用手机类中的属性（成员变量）和行为（成员方法）要先创建一个对象：new一个对象

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

调用成员变量的格式：

对象名.成员变量名；

调用成员方法的格式：

对象名.成员方法名；

public class PhoneTest {	public static void main(String[] args) {		//创建一个手机类的对象		//格式：类名 对象名 = new 类型 （）；		Phone p=new Phone();		int a=0;		/**		 * 先直接调用一次成员变量		 * 采用输出调用		 * 可以查看系统默认值		*/		System.out.println("手机品牌："+p.pinpai+"\n手机颜色："+p.color+"\n手机价格:"+p.price);		//给对象进行赋值		p.pinpai="8848钛金手机";		p.color="白色";		p.price=8848;		//调用		System.out.println("手机品牌："+p.pinpai+"\n手机颜色："+p.color+"\n手机价格："+p.price);		//调用（行为）成员方法		//格式：对象名.成员方法名()；		System.out.println("打电话给"+p.callNumber(a));		p.send();		p.play();			}}

3.变量的区别

简单了解了什么是类和对象中的变量与方法，那类中的变量都有哪些区别呢？

//main中定义的变量也叫局部变量，因为main也属于一个方法

//成员变量和名称可以不可和局部变量一样呢?

可以，但是使用的时候要注意，先找小范围，再找大范围。

1.在类中的位置不同

成员变量：类中方法外

局部变量：方法内或者方法声明上

2.在内存中的位置不同成员变量：堆内存局部变量：栈内存3.生命周期不同成员变量：随着对象的存在而存在，随着对象的消失而消失局部变量：随着方法的调用而存在，随着方法的调用完毕而消失4初始化值不同成员变量：有默认的初始化值

局部变量：没有默认的初始化值，必须先定义，赋值，才能使用。

4.封装

封装（Encapsulation）

就是把数据装在一个盒子（class、类）里面，用特定的关键字（private）保护起来，只有通过盒子（class、类）里面声明为public的方法才可以对这些数据进行访问使用。    //同一个类里面可以随意调用

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点：

1.良好的封装能够减少耦合。

2.类内部的结构可以自由修改。

3.可以对成员变量进行更精确的控制。

4.隐藏信息，实现细节。

封装解释实例：

class Age{	//定义一个年龄变量	int age;	//创建一个输出年龄的方法	public void show() {		System.out.println("年龄为："+age+"岁");	}}public class PrivateTest {	public static void main(String[] args) {		//实例化对象		Private p=new Private();		//初始化对象赋值		p.age=20;		//调用输出		p.show();	}}

上面输出正常年龄没有问题，但是如果赋值不正常（-100岁）的年龄了呢？

所以在类里面加入判断

class Private{	//定义一个年龄变量	int age;	//创建一个输出年龄的方法	public void ageTest(){		if(age<0||age>150)			System.out.println("这人年龄不正常");	}	public void show() {		System.out.println("年龄为："+age+"岁");	}}public class PrivateTest {	public static void main(String[] args) {		//实例化对象		Private p=new Private();		//初始化对象赋值		p.age=-1000;		p.ageTest();		//调用输出		p.show();	}}

输出结果为

/**这人年龄不正常  *年龄为：-1000岁  */

结果虽然提醒了赋值不正确，但仍然输出了年龄,这时我们将age私有（private）起来，只有age类中的方法可以调用

package com.study_oop;class Private{	//定义一个年龄变量	private int age;	//创建一个输出年龄的方法	public void ageTest(){		if(age<0||age>150)			System.out.println("这人年龄不正常");	}	public void show() {		System.out.println("年龄为："+age+"岁");	}}public class PrivateTest {	public static void main(String[] args) {		//实例化对象		Private p=new Private();		//初始化对象赋值		p.age=-1000;    //报错		p.ageTest();		//调用输出		p.show();	}}

这时main方法中的赋值会提示报错，我们无法再使用age了。这说明我们需要在age类里面创建一个公共的方法进行赋值，所以我们接下来就要引入set、get方法。

5. set、get

上面我们由于引入private保护age数据，导致不能直接在main方法中进行赋值，所以我们这时写一个获取和输出的方法：

class Private{	//私有化定义一个年龄	private int age;	//私有化定义一个性别测试get	private String sex;	public void setSex(String a) {		sex=a;	}	public String getSex() {		return sex;	}	public void setAge(int a) {		age=a;	}	public int getAge() {		return age;	}	public void ageTest(){		if(age<0||age>150)			System.out.println("这人年龄不正常");		else			System.out.println("年龄为："+age+"岁");	}}public class PrivateTest {	public static void main(String[] args) {		//实例化对象		Private p=new Private();		//调用设置（set）方法初始化年龄		p.setAge(30);		p.ageTest();		//调用设置（set）方法初始化性别		p.setSex("男");		System.out.println("性别为："+p.getSex());	}}

6. this关键字

由于Java起名要做到见名知意，局部变量名应该与成员变量相同，但是局部变量的名字不能总是与成员变量名一致，所以引入this关键字

this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量

class Private{	//私有化定义一个年龄	private int age;	//私有化定义一个性别测试get	private String sex;		public int getAge() {		return age;	}	public void setAge(int age) {		this.age = age;	}	public String getSex() {		return sex;	}	public void setSex(String sex) {		this.sex = sex;	}	public void ageTest(){		if(age<0||age>150)			System.out.println("这人年龄不正常");		else			System.out.println("年龄为："+age+"岁");	}}public class PrivateTest {	public static void main(String[] args) {		//实例化对象		Private p=new Private();		//调用设置（set）方法初始化年龄		p.setAge(30);		p.ageTest();		//调用设置（set）方法初始化性别		p.setSex("男");		System.out.println("性别为："+p.getSex());	}}

当我们成员变量过多时这样一个一个定义很麻烦，所以在eclipse中提供一个快捷键：alt+shift+s-->r;

7.构造方法（初始化对象）

我们之前要使用对象都先给对象进行了实例化（实例化对象）：

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

没有报错是因为系统默认给我们进行了无参构造给对象进行了初始化！

构造方法：就是给对象进行初始化

构造方法也属于一个类的成员（成员变量、构造方法、成员方法）

当创建对象时，系统会自动调用构造方法

1.没有自定义构造方法时，系统会调用默认构造方法，建议永远自己给出参数构造

2.构造方法可以重载，不同的构造方法名字相同，参数列表不同，参数列表是其识别的依据、标志，类似不同人可能有相同的名字，但有不同的身份证号。

3.当自定义构造方法时，系统依据传入的参数类型、数量，自动匹配构造方法初始化对象

//我们也可以通过有参构造给成员变量赋值，另一种赋值方法就是通过setXX方法；

//无参构造快捷键：alt+shift+s-->c 

构造方法:

  1.方法名和类名相同

  2.构造方法,连void都没有

例题：

 有一个学生类:Student  里面有一些属性；在测试类中创建学生类对象（Student s = new Student() ;）,经历了哪些属性:

8.成员方法

类的组成中还有一个成员：成员方法

成员方法的分类：

1.按照返回值划分：

    a.void的形式：没有具体返回值；

    b.飞void的形式：有具体返回值；

2.按照参数进行划分

    a.空参

    b.有参

class Student {			private String name ;	private String age ;			public Student() { 	}		//成员方法	public String show() { //有返回值没有参数的		return "helloworld" ;	}			//没有返回值,有参数的情况	public void method(String s) {		System.out.println(s);	}		//没有返回值,没有参数的情况	public void function() {		System.out.println("function student...");	}		//有返回值,有参数的情况	public String function2(String s1,String s2) {		return s1+ s2;	}}//测试类public class Test {	public static void main(String[] args) {			//创建学生类对象		Student s = new Student() ;				String str = s.show() ;		System.out.println(str);		s.method("Java");		s.function();		String str2 = s.function2("hello", "world") ;		System.out.println(str2);			}}

转载地址：https://blog.csdn.net/otmqixi/article/details/79904005 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！