黑马程序员笔记（五）——面向对象（概述、类与对象、封装、构造函数、this）

最新推荐文章于 2022-03-10 19:11:24 发布

heshiyingx

最新推荐文章于 2022-03-10 19:11:24 发布

阅读量577

点赞数

分类专栏：黑马程序员——JAVA学习日记

本文链接：https://blog.csdn.net/heshiyingx/article/details/8666827

版权

黑马程序员——JAVA学习日记专栏收录该内容

21 篇文章 0 订阅

订阅专栏

------- android培训、 java培训、期待与您交流！ ----------

一、概述

面向对象的理解（相对与面向过程）
1. 面向对象是相对面向过程而言
2. 面向对象和面向过程都是一种思想
3. 面向过程：强调的是功能行为
4. 面向对象：将功能封装进对象，强调具备了功能的对象。
5. 面向对象是基于面向过程的
面向对象的特点
1. 是一种符合人们思考习惯的思想
2. 可以将复杂的事情简单化
3. 开发的实际过程：
  - 找所需功能的对象
  - 如果对象不存在，就要创建一个对象实体
面向对象的特征：封装、继承、多态（详见后面的封装、继承、多态、版块）

二、类与对象的关系

概念
1. 类：对现实生活中事物的描述，是具体事物的抽象。
2. 对象：就是现实生活中的事物，实实在在的个体。在JAVA中通过new操作符建立的实体，在对内存中。

类的定义：（其实就是在定义类的成员（成员变量和成员函数）属性和行为）

属性：对应类中的成员变量。（如：人的姓名、年龄、体重……）
行为：对应类中的成员函数。（如：人的学习方法、工作方法……）

代码诠释：PersonDemo

class Person	//定义类：Person
{
	String name = "Amy";  //类Person的 姓名属性
	int age = 16;	//类Person的  年龄属性

	void speak()	//类Person的说出自己年龄和姓名的方法。
	{
		System.out.println("My name is " + name);
		System.out.println("I am " + age + " years old");
	}
}
class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person();//产生一个人的对象实体，通过new操作符完成。 p就是一个Person的引用型变量。
		p.speak();//调用这个人的说出自己年龄和姓名的方法。

		//需求：改变这个人的名字。在JAVA中的指挥方式：对象.对象成员
		p.name = "Bob";
		p.speak();
	}
}
/*
运行结果
==========================
My name is Amy
I am 16 years old
My name is Bob
I am 16 years old
==========================
*/

三、成员变量和局部变量

作用范围：
成员变量：作用于整个类中。
局部变量：作用于函数中。

内存中的位置：
成员变量：在对内存中，因为对象的存在，才在内存中存在。
局部变量：在栈内存中，有效范围仅仅是变量所在的函数。

初始化方式：
成员变量：随类的加载而加载，有默认的初始值。
局部变量：只有在调用该方法时，该变量才会被加载，必须手动初始化值之后才可以运算。

四、匿名对象

定义：我们可以不定义变量引用对象，使用new关键字创建对象后直接使用，这样的对象没有名字，所以叫匿名对象。
使用场合：
通常我们需要使用一个对象且只使用一次的时候，就可以使用匿名对象。比如将对象作为一个参数传递给另外一个函数。
可以讲匿名对象作为实际参数进行传递，从而可以不用在main方法中创建一个变量，提高了编程效率，减少了代码书写
注：当一个对象当作实际参数传递时，实际传递的是这个对象在堆内存中的内存地址值。如果在函数中有对该对象进行操作，那么这个对象的值就会被改变。

使用时注意：匿名对象因为没有任何引用到达，在使用一次之后即成为垃圾，所以如果对一个对象进行多个成员调用，必须给这个对象起个名字。
代码诠释：说明的是引用数据类型的参数传递。CarDemo
class Car
{		
	String color = "红色";//描述颜色  为成员变量		
	int num = 4;//描述轮胎数	为成员变量

			//运行行为。
	void run()
	{
		System.out.println(color+".."+num);
	}
}

class  CarDemo
{
	public static void main(String[] args) 
	{
		Car q = new Car();
		q.run();
		change(q);		//往change()中传递的参数q,实际就是把对象q在堆内存中的地址值赋给c.在change()函数中对c的操作，实际就是对对象q的操作。
		q.run();		//所以两次打印的q的属性会不同。

	}

	//需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。
	public static void change(Car c)// 此函数中的c为局部变量，当change()方法结束后，c就消失。
	{
		c.num = 3;
		c.color = "black";
	}
}
/*
运行结果
=====================================
红色..4
black..3
=====================================
*/

五、封装

封装概述
定义：是指隐蔽对象的属性和实现细节，仅对外提供公共访问方式。
好处：
将变化隔离。
便于使用。
提高复用性。
提高安全性。

封装原则：
把不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。
private关键字
private：
是一个权限修饰符。
用于修饰不向外提供的成员变量和成员方法。
私有化的成员只能在本类中直接访问。
私有仅仅是封装的一种表现形式。

将属性私有化后，在类外即使建立了对象也不能直接访问。只有通过提供的方法访问。
之所以对外提供访问方式，就是因为可以在访问方式中假如逻辑判断等语句。对访问的数据进行操作，提高了代码的健壮性。
代码诠释
class Person
{
	private int age;	//成员变量，将其私有化，使外面不能直接访问

	public void getAge()//获取年龄的方法
	{
		System.out.println(age);	
	}

	public void setAge(int x)//设定年龄的方法
	{
		age = x;
	}
}
class PersonDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p.setAge(40);//正确的设置年龄的途径，通过向外提供的方法设置。
		p.getAge();

		p.age = 20;//错误的设定年龄途径    此行代码会报错，因为已经将属性私有，不能直接访问属性
		System.out.println(p.age);//错误的获取年龄途径  原因同上。

	}
}

六、构造函数

特点：
函数名与类名相同。
不能定义返回值类型。
不能写return语句。

作用：给对象进行初始化。
注意:
对象一建立就会调用与之对应的构造函数.

多个构造函数是以重载的形式出现的。

构造函数的定义：
当一个类中没有定义构造函数时，那么系统就会默认给该类加一个空参数的构造函数（类名(){}）。

当在类中自定义了构造函数后默认的构造函数就没有了。

构造函数的访问权限

在定义构造函数时，如无特殊需要，应使用public关键字修饰构造函数。
当构造函数被private修饰时，就不能建立该类的对象。因为外界不能调用该构造函数不能初始化。

构造函数和一般函数的区别
在运行上：
构造函数：在对象一建立就自动执行，给对象初始化。
一般函数：对象调用才执行，是对象的功能。

在执行次数上：
构造函数：只在对象建立的时候运行一次。
一般函数：可以被对象反复调用。

什么时候定义构造函数？
分析事物时，该事物存在一些特性或者行为，那么将这些内容定义在构造函数里。
代码诠释
class Person
{
	Person()
	{
		System.out.println("Person run");
	}
 }

 class PersonDemo
 {
	 public static void mian(String[] args)
	 {
		Person p = new Person(); //使其调用构造函数给对象进行初始化
	 }
 }
 /*
 运行结果
 =========================
 Person run
 =========================
 */

七、构造代码块

作用：给对象初始化，对象一建立就运行，并且优先于构造函数执行。
构造代码块和构造函数的区别：
构造代码块：是给所有对象进行统一初始化。
构造函数：是给对应的对象初始化。定义的是不同对象共性的初始化内容。

代码诠释：构造代码块和构造函数

八、this关键字

需求：当成员变量和局部变量重名的时候，不能把局部变量的值赋给成员变量。

class Person
{
	private String name;	//定义人的两个属性
	private int age;
	
	Person(String name,int age)//构造函数，对属性进行初始化
	{
		name = name;
		age = age;
	}

	public void speak()//说出自己的姓名和年龄
	{
		System.out.println("name="+name+"...age="+age);
	}
	
}

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

		Person p = new Person("lisi",30);
		p.speak();

	}
}
/*
运行结果
================================
name=null...age=0
================================
*/

特点：this代表其所在函数所属对象的引用。
this的应用：
- 当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

将上面的代码优化后就可以实现赋值

class Person
{
	private String name;	//定义人的两个属性
	private int age;
	
	Person(String name,int age)//构造函数，对属性进行初始化
	{
		this.name = name;
		this.age = age;
	}

	public void speak()//说出自己的姓名和年龄
	{
		System.out.println("name="+this.name+"...age="+this.age);
	}
	
}

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

		Person p = new Person("lisi",30);
		p.speak();

	}
}
/*
运行结果
================================
name=lisi...age=30
================================
*/