摘要:面向对象思维方式将复杂的问题简单化。给对象起个名字。是类类型的变量。通过已有的对象调用该对象的功能。格式对象对象成员可以该对象的属性赋值。这时会有两个引用同时指向堆中的同一个对象。对象,用于描述现实中的个体,它是类的实例。
01面向对象和面向过程的思想
* A: 面向过程与面向对象都是我们编程中,编写程序的一种思维方式 * a: 面向过程的程序设计方式,是遇到一件事时,思考“我该怎么做”,然后一步步实现的过程。 * b: 面向对象的程序设计方式,是遇到一件事时,思考“我该让谁来做”,然后那个“谁”就是对象,他要怎么做这件事是他自己的事,反正最后一群对象合力能把事就好就行了。02面向对象的思想的生活案例
* A: 买电脑(组装机) * a: 面向过程:自己该怎么做 * b: 面向对象:找人帮我们做03面向对象好处
* A: 面向对象好处 * a: 面向对象思维方式是一种更符合人们思考习惯的思想 * b: 面向过程思维方式中更多的体现的是执行者(自己做事情),面向对象中更多的体现是指挥者(指挥对象做事情)。 * c: 面向对象思维方式将复杂的问题简单化。04大象装进冰箱的代码案例
* A: 需求:把大象装冰箱里 * a: 面向过程 * 自己打开冰箱门 * 自己将大象装进去 * 自己关闭冰箱门 * b: 面向对象 * 分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具 备如下功能 * 冰箱打开 * 冰箱存储 * 冰箱关闭 * B: 通过伪代码描述大象和冰箱 * 描述大象: class 大象 { } * 描述冰箱 class冰箱 { void 打开(){} void 存储(大象){} void 关闭(){} } * C: 使用对象: * 1、创建冰箱的对象 * 冰箱 bx = new 冰箱(); * 2、调用冰箱的功能 * 对象.功能(); * bx.打开(); * bx.存储(new 大象()); * bx.关闭(); * D:总结: * 1、先按照名词提炼问题领域中的对象 * 2、对对象进行描述,其实就是在明确对象中应该具备的属性和功能 * 3、通过new的方式就可以创建该事物的具体对象 * 4、通过该对象调用它以后的功能。05定义小汽车类
* A: 分析小汽车的属性和功能 * 属性 * 颜色 * 轮胎个数 * 功能 * 运行 * B: 通过伪代码描述小汽车 * 小汽车{ * 颜色 * 轮胎个数 * 运行(){} * } * C:通过JAVA代码描述小汽车 * public class Car { * String color; * int number; * void run() { * System.out.println(color + ":" + number); * } * }01测试汽车类
* A: 创见对象的格式 * a: 类名 变量名 = new 类名(); * B: 测试汽车类 public class CarDemo { public static void main(String[] args) { /* 测试:Car类中的run方法。 */ // 1,创建Car的对象。给对象起个名字。 Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。 // 2,通过已有的对象调用该对象的功能。格式:对象.对象成员; // 3,可以该对象的属性赋值。 c.color = "red"; c.number = 4; c.run(); } }02对象的内存图
* 见课后资料:对象的内存图.JPG03类和对象的关系
* A: 类和对象的关系 * 类是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体 * B: 举例 * 可以将玩具模型看作是一个类,将一个个玩具看作对象,从玩具模型和玩具之间的关系便可以看出类与对象之间的关系04成员变量和局部变量的区别
区别一:定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二:在内存中的位置不同
成员变量存储在对内存的对象中
局部变量存储在栈内存的方法中
区别三:声明周期不同
成员变量随着对象的出现而出现在堆中,随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中,随着方法的弹栈而消失
区别四:初始化不同
成员变量因为在堆内存中,所有默认的初始化值
局部变量没有默认的初始化值,必须手动的给其赋值才可以使用。
01方法参数是基本数据类型和引用数据类型* A.基本类型 class Demo { public static void main(String[] args) { int x = 4; show(x); System.out.println("x="+x); } public static void show(int x) { x = 5; } } 基本类型作为参数传递时,其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show(),当在show()方法中x接受到了复制的值,再在show()方法中对x变量进行操作,这时只会影响到show中的x。当show方法执行完成,弹栈后,程序又回到main方法执行,main方法中的x值还是原来的值。 * B.引用类型 class Demo { int x ; public static void main(String[] args) { Demo d = new Demo(); d.x = 5; show(d); System.out.println("x="+d.x); } public static void show(Demo d) { d.x = 6; } } 当引用变量作为参数传递时,这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的d.x=6时,会根据d所持有的引用找到堆中的对象,并将其x属性的值改为6.show方法弹栈。 由于是两个引用指向同一个对象,不管是哪一个引用改变了引用的所指向的对象的中的值,其他引用再次使用都是改变后的值。 * C.结论 * 对于基本类型形式参数改变不会影响到实际参数 * 对于引用类型形式参数改变会影响到实际参数02封装的概述
* A.面向对象三大特征 * 封装、继承、多态 * B.封装表现 * 1、方法就是一个最基本封装体 * 2、类其实也是一个封装体 * C.封装的好处 * 1、提高了代码的复用性 * 2、隐藏了实现细节,还要对外提供可以访问的方式。便于调用者的使用。这是核心之一,也可以理解为就是封装的概念 * 3、提高了安全性03封装的生活中的举例
* A.封装的生活中的举例 机箱: 一台电脑,它是由CPU、主板、显卡、内存、硬盘、电源等部件组长,其实我们将这些部件组装在一起就可以使用电脑了,但是发现这些部件都散落在外面,很容造成不安全因素,于是,使用机箱壳子,把这些部件都装在里面,并在机箱壳上留下一些插口等,若不留插口,大家想想会是什么情况。 总结:机箱其实就是隐藏了办卡设备的细节,对外提供了插口以及开关等访问内部细节的方式。 * B.总结 * 机箱其实就是隐藏了办卡设备的细节,对外提供了插口以及开关等访问内部细节的方式04private关键字
* A.private概述 * private可以修饰成员内容包括成员方法和成员变量 * 被private修饰的内容不能在其他类访问 * B.使用步骤 * 1、通过private修饰属性 * C.完整代码 class Person { private int age; private String name; public void show() { System.out.println("age=" + age + ",name" + name); } }01get和set方法
* A.get和set方法 * 年龄已被私有,错误的值无法赋值,可是正确的值也赋值不了,这样还是不行,那肿么办呢?按照之前所学习的封装的原理,隐藏后,还需要提供访问方式。只要对外提供可以访问的方法,让其他程序访问这些方法。同时在方法中可以对数据进行验证。
一般对成员属性的访问动作:赋值(设置 set),取值(获取 get),因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。
class Person { // 私有成员变量 private int age; private String name; // 对外提供设置成员变量的方法 public void setAge(int a) { // 由于是设置成员变量的值,这里可以加入数据的验证 if (a < 0 || a > 130) { System.out.println(a + "不符合年龄的数据范围"); return; } age = a; } // 对外提供访问成员变量的方法 public void getAge() { return age; } } * 总结 * 类中不需要对外提供的内容都私有化,包括属性和方法。
以后再描述事物,属性都私有化,并提供setXxx getXxx方法对其进行访问
* 注意 * 私有仅仅是封装的体现形式而已02私有化Person类带get,set
* 标准代码 package cn.itcast.demo05; /* * 类描述人: * 属性: 姓名和年龄 * 方法: 说话 * * 私有化所有的属性 (成员变量) ,必须写对应的get/set方法 * 凡是自定义的类,自定义成员变量,应该私有化,提供get/set * * this关键字: * 区分成员变量和局部变量同名情况 * 方法中,方位成员变量,写this. */ public class Person { private String name; private int age; // set方法,变量name,age赋值 public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } // get方法,变量name,age获取值 public int getAge() { return age; } public String getName() { return name; } public void speak() { String name = "哈哈"; int age = 16; System.out.println("人在说话 " + this.name + "..." + this.age); } } * 标准测试代码 package cn.itcast.demo05; public class PersonTest { public static void main(String[] args) { Person p = new Person(); //调用set方法,对成员变量赋值 p.setAge(18); p.setName("旺财"); p.speak(); //调用get方法,获取成员变量的值 // System.out.println(p.getName()); // System.out.println(p.getAge()); } }03this关键字_区分成员变量和局部变量的同名
* A.什么时候用 * 当类中存在成员变量和局部变量同名的时候为了区分,就需要使用this关键字 * B.代码 class Person { private int age; private String name; public void speak() { this.name = "小强"; this.age = 18; System.out.println("name=" + this.name + ",age=" + this.age); } } class PersonDemo { public static void main(String[] args) { Person p = new Person(); p.speak(); } }04this内存图
* A.this内存图 * 见附件:this内存图.jpg01this的年龄比较
* A.需求:在Person类中定义功能,判断两个人是否是同龄人 * B.代码 class Person { private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void speak() { System.out.println("name=" + this.name + ",age=" + this.age); } // 判断是否为同龄人 public boolean equalsAge(Person p) { // 使用当前调用该equalsAge方法对象的age和传递进来p的age进行比较 // 由于无法确定具体是哪一个对象调用equalsAge方法,这里就可以使用this来代替 /* * if(this.age == p.age) { return true; } return false; */ return this.age == p.age; } }02随机点名器案例重构
* A.需求:随机点名器,即在全班同学中随机的找出一名同学,打印这名同学的个人信息 它具备以下3个内容: 存储所有同学姓名 总览全班同学姓名 随机点名其中一人,打印到控制台 * B.代码 import java.util.ArrayList; import java.util.Random; import java.util.Scanner; /** * 思路: * 第一步:存储全班同学信息 * 第二步:打印全班同学每一个人的信息 * 第三部:随机对学生点名,打印学生信息 */ public class Test { public static void main(String[] args) { ArrayList03总结list = new ArrayList (); //1.1创建一个可以存储多个同学名字的容器 //1.存储全班同学信息 addStudent(list); //2.打印全班同学每一个人的信息(姓名、年龄) printStudent(list); //3.随机对学生点名,打印学生信息 randomStudent(list); } public static void addStudent(ArrayList list) { //键盘输入多个同学名字存储到容器中 Scanner sc = new Scanner(System.in); for (int i = 0; i < 3; i++) { //创建学生 Student s = new Student(); System.out.println("存储第"+i+"个学生姓名:"); String name = sc.next(); s.setName(name); System.out.println("存储第"+i+"个学生年龄:"); int age = sc.nextInt(); s.setAge(age); //添加学生到集合 list.add(s); } } /** 2.打印全班同学每一个人的信息(姓名、年龄) */ public static void printStudent (ArrayList list) { for (int i = 0; i < list.size(); i++) { Student s = list.get(i); System.out.println("姓名:"+s.getName() +",年龄:"+s.getAge()); } } /** 3.随机对学生点名,打印学生信息 */ public static void randomStudent (ArrayList list) { //在班级总人数范围内,随机产生一个随机数 int index = new Random().nextInt(list.size()); //在容器(ArrayList集合)中,查找该随机数所对应的同学信息(姓名、年龄) Student s = list.get(index); System.out.println("被随机点名的同学:"+s.getName() + ",年龄:" + s.getAge()); } } /** * 学生信息类 */ public class Student { private String name; // 姓名 private int age; // 年龄 public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
A.类与对象
类,用于描述多个对象的共同特征,它是对象的模板。
对象,用于描述现实中的个体,它是类的实例。
类的定义:使用关键字class来定义java中的类
格式:
class 类名 {
//属性
数据类型 变量名;
…
//方法
修饰符 返回值类型 方法名(参数){ }
…
}
B.创建对象:
格式:
类名 对象名 = new 类名();
C.封装(private关键字)
封装,把对象的属性与方法的实现细节隐藏,仅对外提供一些公共的访问方式
封装的体现:
变量:使用 private 修饰,这就是变量的封装
方法:也是一种封装,封装了多条代码
类: 也是一种封装,封装了多个方法
D.private关键字,私有的意思
它可以用来修饰类中的成员(成员变量,成员方法)
private的特点:
private修饰的成员只能在当前类中访问,其他类中无法直接访问
E.this关键字
this关键字,本类对象的引用
this是在方法中使用的,哪个对象调用了该方法,那么,this就代表调用该方法的对象引用
this什么时候存在的?当创建对象的时候,this存在的
this的作用:用来区别同名的成员变量与局部变量(this.成员变量)
public void setName(String name) {
this.name = name;
}
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/67149.html
摘要:前言是面对对象的语言,因此有必要单独纪录下对象的各种定义和理解。面对对象基本概述概述是基于面向过程的变成思想,是对面向过程的一种封装。面对对象开发就是不断的创建对象,使用对象,指挥对象做事情。面对对象设计其实就是在管理和维护对象之间的关系。 前言 java是面对对象的语言,因此有必要单独纪录下对象的各种定义和理解。 面对对象,主要包括:面向对象思想,类与对象及其使用,对象的内存图,成...
摘要:可处理中成员变量和参数重名的情况。可看作是一个变量,它的值是当前对象的引用声明的成员变量为成员变量,它为该类的公用变量,在第一次使用时被初始化。经常出,不用逮压路面上的小石子异常是提供的用于处理程序中错误的一种机制。 Chap 3 Java OO focus on : * 对象和类的概念 * 类 (对类) 之间的关系 * 面向对象...
摘要:面向对象思想概述了解面向对象开发就是不断的创建对象,使用对象,指挥对象做事情。面向对象设计其实就是在管理和维护对象之间的关系。建议文件名称和测试类名称一致。 1.面向对象思想概述(了解) A:面向对象开发就是不断的创建对象,使用对象,指挥对象做事情。 B:面向对象设计其实就是在管理和维护对象之间的关系。 C:面向对象特征封装(encapsulation)、继承(inheritance...
阅读 3348·2023-04-25 20:37
阅读 3127·2021-09-07 09:59
阅读 1652·2019-08-29 12:43
阅读 1169·2019-08-28 18:27
阅读 467·2019-08-26 13:50
阅读 1999·2019-08-26 10:33
阅读 3547·2019-08-23 18:39
阅读 2348·2019-08-23 18:09