11 面向对象（面向对象的思想；类与对象及其应用；对象的内存图；成员变量和局部变量的区别；匿名对象；封装(private)；this关键字）
文章目录
- 面向对象的思想
-
- 面向对象思想概述
- 面向对象思想举例
- 类与对象及其应用
-
- 类与对象概述
- 手机类的定义 手机类的使用
- 对象的内存图
-
- 一个对象的内存图
- 二个对象的内存图
- 三个引用二个对象的内存图
- 成员变量和局部变量的区别
-
- 成员变量 局部变量 区别
- 方法的形式参数是类名的时候如何调用
- 匿名对象
-
- 匿名对象的概述和应用
- 封装(private)
-
- 封装的概述
- private关键字的概述和特点
- private常见应用
- this关键字
-
- this关键字的概述和应用
面向对象的思想
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//对象：万物皆对象
//面向对象：指挥对象帮你做事情
//现实世界，由万事万物所构成--事物
//事物---猫 --->属性,行为
//事物----------------------------> Java中
// 猫--->属性, 行为（功能） ----->>> 类 class--->成员属性（成员变量）, 成员功能（成员方法）
//类，是我们Java中最小单位，体现的是一种封装的思想，封装了属性和功能
//Java中面向对象的三大特征：封装，继承，多态
}
}
面向对象思想概述
-
面向过程思想概述
我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。
一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言 -
面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。 -
面向对象思想特点
a:是一种更符合我们思想习惯的思想 懒人思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者 角色发生了转换
面向对象思想举例
- 举例:
洗衣服：换下脏衣服—盛水----浸泡------手搓----漂清—晾干
全自动洗衣机----------- 一键洗衣 - 面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism) - 面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。
类与对象及其应用
类与对象概述
-
我们学习编程是为了什么
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。 -
我们如何描述现实世界事物
举例: 描述学生事物
姓名 , 年龄 , 性别 …
学习 , 吃饭 , 睡觉 …属性: 就是该事物的描述信息
行为: 就是该事物能够做什么
我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
由此我们就得到了现实中的事物和类的对应关系
事物 类
属性 ----------------- 成员变量
行为 ----------------- 成员方法
- 定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。 - 类和对象的概念
a:类：是一组相关的属性和行为的集合
b:对象：是该类事物的具体体现
c:举例：
类------学生
对象------班长就是一个对象 - 举例 (Person)
//定义一个类：class
package org.westos.demo;
public class Person { //定义的Person这个类里封装了三个属性和三个功能
//成员属性，成员变量：定义在类中方法外
String name="zhangsan"; //名字
int age; //年龄 // 没赋值前的默认值都是0
char sex; //性别
//成员功能，成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void playGame() {
System.out.println("打豆豆");
}
}
//如何使用定义好的一个类
package org.westos.demo;
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
// 类：他是一个抽象的概念，他不能直接使用，如果要使用，我们需要对类进行实例化
//所谓实例化，就是创建该类对象，因为对象才是类的具体表现
// 怎么创建一个类的对象呢，使用关键字new
Person person = new Person();
//该类对象创建成功后，使用该类对象，就可以调用类中的属性和功能
//先给属性赋值
person.name = "王五";
person.age = 23;
person.sex = '男';
//获取属性的值
String name = person.name;
int age = person.age;
char sex = person.sex;
System.out.println(name);
System.out.println(age);
System.out.println(sex);
//使用功能
person.eat();
person.sleep();
person.playGame();
}
}
手机类的定义 手机类的使用
- 定义
属性 ----- 成员变量
行为 ----- 成员方法 - 使用
文件名问题
——在一个java文件中写两个类：一个基本的类，一个测试类。
——建议：文件名称和测试类名称一致。
如何使用呢?
——创建对象使用。
如何创建对象呢?
——格式：类名 对象名 = new 类名();
如何使用成员变量呢?
——格式：对象名.变量名
如何使用成员方法呢?
——格式：对象名.方法名(…) - 举例 (Phone)
package org.westos.demo;
public class Phone {
//成员属性
String name="小米";
double price;
//成员功能
public void call(String name){
System.out.println("给"+name+"打电话"); //传参 用name这个参数
}
public void sendMsg(String name,String content){
System.out.println("给" + name + "发短信内容"+content);
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Phone phone = new Phone();
phone.name="魅族";
phone.price=1000; // 给属性赋值
System.out.println(phone.name);
System.out.println(phone.price);
phone.call("雷总");
phone.sendMsg("黄老板","国庆阅兵怎么没去？");
System.out.println("------------------------------");
Phone phone1 = new Phone();
phone1.name="华为";
phone1.price=2000;
System.out.println(phone1.name);
System.out.println(phone1.price);
phone1.call("你好！！！");
phone1.sendMsg("余大嘴","你好！");
}
}
对象的内存图
一个对象的内存图
画图演示: 一个对象
二个对象的内存图
画图演示: 二个不同的对象
三个引用二个对象的内存图
画图演示: 三个引用，有两个对象的引用指向同一个地址
成员变量和局部变量的区别
成员变量 局部变量 区别
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
//成员变量和局部变量的区别
//成员变量：定义在类中方法外的变量
//局部变量：定义在方法中的变量，或方法声明上的形参
//成员变量存在堆内存，局部变量存在栈内存
//成员变量：随着对象的创建而产生，随着对象被回收而消失
//局部变量：随着方法的调用而产生，随着方法的调用完毕而消失
//成员变量：属于对象,也就做实例变量 局部变量：属于方法
//局部变量没有默认值。成员变量有默认值
- 注意事项：: 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.show("王五");
}
}
class Student {
//在一个java文件中可以定义多个类 但是public只能加给其中一个类 加给有主方法的那个 //不建议并列定义多个类
String name = "张三";
public void show(String mingzi) {
System.out.println(mingzi);//王五 // 取到student.show("王五"); 这个show方法里的 王五 mingzi
System.out.println(name);//张三 //局部里面没有这个name 就到成员里去找 找到String name = "张三";
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.show("王五");
}
}
class Student {
String name="张三";
public void show(String name) {
//当成员变量和局部变量重名时，那么访问变量的规则就遵从就近原则
//就近原则：先从局部范围找，找个变量，找到就使用，如果找不到，去成员位置找，找到就成员
System.out.println(name);//王五 //成员变量name和局部变量name重名 遵从就近原则 先从局部范围找
System.out.println(name);//王五
}
}
方法的形式参数是类名的时候如何调用
A:Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
B:方法的参数是类名
如果你看到了一个方法的形式参数是一个 类 类型(引用类型)，这里其实需要的是该类的对象。
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Teacher teacher = new Teacher();//当你以后看到一个方法的形参，要一个 类 类型(引用类型)。你就传该类的一个对象
//这里new一个Teacher的对象 分析程序时始终关注这个new的对象 Teacher
show(200, teacher); //调用方法show
int age = teacher.age;
System.out.println(age); // 50 //teacher.age = 20 后进行 teacher.test(50)的调用 重新赋值 变成50
}
public static void show(int num, Teacher teacher) {
System.out.println(num);//200
teacher.age = 20;
teacher.test(50);//调用方法test //对age重新赋值 将20变为50
}
}
class Teacher {
int age;
public void test(int n) {
this.age = n;
System.out.println(age); //50
}
}
匿名对象
匿名对象的概述和应用
- 什么是匿名对象
就是没有名字的对象
只有创建对象的语句，确没有把对象地址值赋值给某个变量
Person p=new Person; //创建一个普通对象
new Person(); //创建一个匿名对象
- 匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//匿名对象：没有名字的对象
/* A a = new A();
a.show();
a.show();
a.show();//同一个对象 把方法调用了3次
new A().show();
new A().show();//每一次都调用了new新对象 每new一次都是新对象
*/
//这个类中的方法，我只想调用一次，我可以使用匿名对象来调用 //new A().show();//每次调用新对象
A a = new A();
test(a); //new出来 把对象名字a传进去就行
test(a);
//匿名对象可以作为参数来传递
test(new A());//匿名对象 不起名 仅仅是A类型
}
public static void test(A a) { //test方法 要 A类型 (引用类型)
//如果一个方法的形参是一个 类 类型(引用类型)，这里其实需要的是该类的对象 需要new出来
a.show();
}
}
class A {
public void show() {
System.out.println("这是一个show方法");
}
}
封装(private)
封装的概述
A:封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
C:封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性
D:封装原则
将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共方法对其访问
- 举例 （Person）
package org.westos.demo;
public class Person {
//private 私有的，是一个权限修饰符，可以修饰成员变量和成员方法，修饰后，该成员只能在本类中访问
//原本在MyTest.java中，可以通过“对象名.属性名=值”（如p.age=230）这种方式来赋值
//现在Person.java中，将int age变为private int age，另一个类MyTest中p.age=230就无法访问了，age的值只在本类中访问
private String name;
private int age;
//成员变量全部私有 用 get set 让用户可以间接的获得或设置
//get set 方法的规范 (age--getAge，name--setName:首字母要大写）
//提供一个公共的赋值的方法
//get set 方法 必须是公共的 要确保用户在另一个类中能设置这些值
public void setAge(int nianLing) {
if (nianLing >= 0 && nianLing <= 100) {
age = nianLing;
} else {
System.out.println("这个年龄的数据不合理");
}
}
public int getAge() { //用户可以获取age
return age;
}
public void setName(String mingzi) { //用户可以设置name
name = mingzi;
}
public String getName() { //用户可以获取name
return name;
}
private void show() {
System.out.println(name);
System.out.println(age);
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//我们通过“对象名.属性名=值”这种赋值方式， 不能验证数据的合理性
//我们现在想要对赋值的数据进行合理性的验证，需要屏蔽掉“对象名.属性名=值”这种赋值方式
//怎么来屏蔽掉呢?可以使用一个关键字private 私有的，是一个权限修饰符
Person p = new Person();
//p.name="张三"; //被Person.java中的 private String name屏蔽
//p.age=230;//被Person.java中的 private int age 屏蔽
//private屏蔽掉直接赋值方式后，可以提供一个间接的赋值方式
//设置值
p.setName("张三"); //设置name
p.setAge(20); //设置age
//获取属性值的方法 //在Person.java中 public int getAge(){return age;}
int age = p.getAge(); //返回age
String name = p.getName(); //返回name
System.out.println(name);
System.out.println(age);
// p.show();//在Person.java中 是private void show() 只能本类访问 所以这里不能访问
}
}
- 举例 （Phone）
package org.westos.demo;
public class Phone {
//私有成员变量
private String name;
private double price;
//提供公共的set get 方法
public void setName(String mingzi){
name=mingzi;
}
public void setPrice(double jiage){
price=jiage;
}
public String getName(){
return name;
}
public double getPrice(){
return price;
}
}
package org.westos.demo;
public class Test {
public static void main(String[] args) {
Phone phone = new Phone();
phone.setName("小米"); //设置
phone.setPrice(500);
String name = phone.getName(); //获取
double price = phone.getPrice();
System.out.println(name+"===="+price);
}
}
private关键字的概述和特点
A:private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
B:案例演示
private关键字特点
private常见应用
private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法
this关键字
this关键字的概述和应用
- 为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题 - this关键字特点
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁 - this的应用场景
解决局部变量隐藏成员变量 - 案例演示
this的应用场景
package org.westos.demo;
public class Phone {
//私有成员变量
private String name;
private double price;
//提供公共的set get 方法
public void setName(String mingzi){
name=mingzi;
}
/*public void setName(String name) { //如果这里变成(String name) 那么成员变量和局部变量就都是name重名了
//就近原则 name不会去找前面private String name中的name
//而是会去找public void setName(String name)中的name 就相当于自己赋值给自己了
name = name;
}*/
/*//如果想区分name的话 可以使用关键字this
public void setName(String name) {
this.name = name; // 变为 this.name
}*/
}
- 举例 （Phone）
package org.westos.demo;
public class Phone {
//私有成员变量
//this 表示本类的一个引用。你可以理解为本类的一个对象，哪个对象调用这个方法，那么方法中的this就代表这个对象
private String name;
private double price;
//提供公共的set get 方法 //方法中的this 就代表那个调用者，谁调用就代表谁
public void setName(String name){
System.out.println("this代表调用者的地址值"+this);
this.name=name;
//this加在方法public void setName(String name){}中，这个方法是phone在调用，所以this就代表这个对象phone
}
public void setPrice(double price){
System.out.println("this代表调用者的地址值" + this);
this.price=price;
}
public String getName(){
return name;
}
public double getPrice(){
return price;
}
}
package org.westos.demo;
public class Test {
public static void main(String[] args) {
Phone phone = new Phone();
System.out.println(phone+"调用者的地址值");
phone.setName("小米");
phone.setPrice(500);
String name = phone.getName();
double price = phone.getPrice();
System.out.println(name+"===="+price);
System.out.println("------------------------");
Phone phone2 = new Phone();//phone2调取的话 this代表phone2
System.out.println(phone2 + "调用者的地址值");
phone2.setName("小米");
phone2.setPrice(500);
String name2 = phone2.getName();
double price2 = phone2.getPrice();
System.out.println(name2 + "====" + price2);
}
}
//快速生成get set 方法
package org.westos.demo;
public class Phone {
private String name;
private double price;
private String color;
//快捷键 "alt+insert" 在弹出窗口中选 getterAndSetter；"ctrl+a" 把name price color三个全选中
//只想选两个 就按住ctrl别松 选两个就行 // 也可以自己根据意愿去选择
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}