Java面向对象（九）——面向对象、类与对象（局部和全局变量，基本和引用类型数据传参）、封装（private、this）

最新推荐文章于 2021-03-01 11:05:10 发布

kww_

最新推荐文章于 2021-03-01 11:05:10 发布

阅读量289

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_40243295/article/details/111589074

版权

java 专栏收录该内容

44 篇文章 7 订阅

订阅专栏

说明：

JAVA(一)——（八）为Java基础

JAVA(九)——（十四）为Java面向对象

第一章面向对象

1.1面向过程与面向对象

面向过程是以事物为中心，编程的时候把解决问题的步骤分析出来，用函数把这些步骤实现。它们不支持丰富的“面向对象”特性（比如继承、多态）。面向过程的程序设计方式，是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。

当问题的规模变大时，面向过程就不易解决了，因此有了面向对象。

面向对象就是将问题分解为对象。面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象。世界上的每个人，每个物体，都可以看做是一个对象。每个对象都有自己的属性和行为，对象与对象之间通过方法来交互。

第二章类与对象

2.1类与对象的含义

类的含义：

类的真正意义就是在描述事物。属性和方法都属于类的成员。每个事物是一个类，事物的功能就是方法
类是具有相同特性(数据元素)和行为(功能)的对象的抽象就是类。类的实例化是对象，因此类实际上就是一种数据类型。
类的定义：使用关键字class来定义java中的类

对象的含义：

对象是类的实例化，代表一个具体的事物。
类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

类，用于描述多个对象的共同特征，它是对象的模板。

对象，用于描述现实中的个体，它是类的实例。

2.2成员变量与局部变量的区别

类的真正意义就是在描述事物。属性和功能统称为事物中的成员。

事物的成员分为两种：成员属性和成员功能。

属性，为成员变量
方法，为成员功能

1.定义位置不同

成员变量：写在类中，方法外中
局部变量：写在方法内

2.默认值不同

成员变量：有默认值
局部变量：无默认值，使用前必须初始化

3.内存位置不同

成员变量：跟着对象进入堆内存
局部变量：跟随着自己的方法进入栈内存（main中定义的也为局部变量）
内存分配：栈是运行方法用的，堆是存储容器用的

4.生命周期不同

成员变量，跟随对象，在堆中存储，内存等待JVM清理
局部变量，跟随方法，方法出栈则结束，生命周期相对较短

5.作用域不同

成员变量：作用范围是整个类
局部变量：方法内

2.3基本类型和引用类型作为参数传递

数组和对象都是引用类型。

举例：

类的定义：

package day9;

public class Person {
	   String name ;
	}

调用：

package day9;

public class TestPerson {
	public static void main(String[] args) {
		int a = 1;
		function(a);
		System.out.println(a); //1
		
		Person p = new Person();
		p.name = "张三";
		System.out.println(p.name);//张三
		
		function(p);
		
		System.out.println(p.name);//李四
	}
	/*
	 * 定义方法,参数类型是引用数据类型
	 * 参数是Person类型
	 * p接受的是一个内存的地址
	 * main 中的变量p
	 * function  中的变量p  保存的地址是一样的
	 */
	public static void function(Person p){
		p.name = "李四";
	}
	
	/*
	 * 定义方法,参数类型是基本数据类型
	 */
	public static void function(int a){
		a+=5;
	}
}

结果：

基本类型传递参数，如果没有return，则原来的值不会发生变化。

引用类型传递的是地址，最终值将被修改。

第三章封装

3.1封装概述

封装，把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式。

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

封装的体现：

变量:使用 private 修饰，这就是变量的封装
方法:也是一种封装，封装了多条代码
类：也是一种封装，封装了多个方法

封装的好处：

1、提高了代码的复用性。

2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3、提高了安全性。

3.2私有private

private：是关键字也是一个修饰符 private(私有，权限修饰符)，它可以用来修饰类中的成员(成员变量，成员方法)。

private的特点：private修饰的成员只能在当前类中访问，其他类就无法直接访问。

一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。

私有化所有的属性 (成员变量) ,必须写对应的get/set方法。
凡是自定义的类,自定义成员变量,应该私有化,提供get/set。

类的定义：

package day9;
/*
 *   类描述人:
 *     属性: 姓名和年龄
 *     方法: 说话
 *   
 *   私有化所有的属性 (成员变量) ,必须写对应的get/set方法
 *   凡是自定义的类,自定义成员变量,应该私有化,提供get/set
 *   
 *   this关键字:
 *     区分成员变量和局部变量同名情况
 *     方法中,方位成员变量,写this.
 */
public class Person_1 {
	private String name;
	private int age;
	
	public void setAge(int a) {
		age=a;
	}
	public void setName(String n) {
		name=n;
	}	
	public int getAge() {
		return age;
	}
	public String getName() {
		return name;
	}
	public void speak() {
		System.out.println("人在说话  " + name + "..." + age);
	}

}

调用：

package day9;

public class PersonTest_1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person_1 p = new Person_1();
		//调用set方法，对成员变量赋值
		p.setAge(18);
		p.setName("花花");
		p.speak();
		
		//调用get方法，获取成员变量的值
		System.out.println(p.getAge());
		System.out.println(p.getName());
	}

}

总结：

类中不需要对外提供的内容都私有化，包括属性和方法。

以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。

注意：私有仅仅是封装的体现形式而已。

3.3 this关键字

this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

this关键字:本类的对象引用，哪个对象调用了this所在的方法，this就代表哪个对象。

this存在时间：当创建对象的时候，this存在

举例：成员变量和局部变量冲突时：此时输出的是局部变量：哈哈（就近原则）

添加this后：

想输出成员变量需要加this.

this内存图：

例1：随机点名器

定义类：

package day9;
/*
 *  学生类:
 *    属性: 姓名,年龄
 */
public class Student {
	private String name;
	private int age;
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(int age) {
			this.age= age;
		}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
		
	
	}
}

代码实现：

package day9;

import java.util.ArrayList;
import java.util.Random;

/*
 *  随机点名器案例
 *   1. 创建集合,将Student对象存储到集合中
 *   2. 总览所有学生的信息
 *       将存储到集合中的Student对象遍历出来
 *   3. 随机学生
 *       随机数,作为索引,到集合中去查找元素
 */
public class CallName {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<Student> st= new ArrayList<Student>();
		addStudent(st);
		//printStudent(st);
		randomStudent(st);
	}
public static void addStudent(ArrayList<Student> array) {
	Student s1= new Student();
	Student s2= new Student();
	Student s3= new Student();
	Student s4= new Student();
	s1.setAge(10);
	s1.setName("华华");
	
	s2.setAge(12);
	s2.setName("强强");
	
	s3.setAge(13);
	s3.setName("爱丽丝");
	
	s4.setAge(15);
	s4.setName("徐徐");
	
	array.add(s1);
	array.add(s2);
	array.add(s3);
	array.add(s4);
}

public static void printStudent(ArrayList<Student> array) {
	for(int i=0;i<array.size();i++) {
		Student s=array.get(i);
		System.out.println(s.getName()+" "+s.getAge());
	}
	
}
public static void randomStudent(ArrayList<Student> array) {
	Random r= new Random();
	int num= r.nextInt(array.size());
	Student s=array.get(num);
	System.out.println(s.getName());
}
}

kww_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java面向对象（九）——面向对象、类与对象（局部和全局变量，基本和引用类型数据传参）、封装（private、this）

JAVA(一)——（八）为Java基础JAVA(九)——（十四）为Java面向对象第一章面向对象1.1面向过程与面向对象面向过程是以事物为中心，编程的时候把解决问题的步骤分析出来，用函数把这些步骤实现。它们不支持丰富的“面向对象”特性（比如继承、多态）。面向过程的程序设计方式，是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。当问题的规模变大时，面向过程就不易解决了，因此有了面向对象。面向对象就是将问题分解为对象。面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，
复制链接

扫一扫