类与对象、封装、构造方法
1. 面向对象思想
1.1 面向对象思想概述
概述
Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具有自己的属性和行为。面向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征笼统出来,形容成计算
机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。
特点
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。
面向对象的语言中,包含了三大基本特征,即封装、继承和多态。
1.2 类和对象
什么是类
- 类 :是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来形容该类事物。
现实中,形容一类事物: - 属性 :就是该事物的状态信息。
- 行为 :就是该事物能够做什么。
什么是对象
- 对象 :是一类事物的具体表现。对象是类的一个实例(对象并不是找个女朋友),必然具有该类事物的属性和行为。
现实中,一类事物的一个实例:一只小猫。
类与对象的关系
- 类是对一类事物的形容,是 笼统的。
- 对象是一类事物的实例,是 具体的。
- 类是对象的模板,对象是类的实体 。
1.3 类的定义
事物与类的比照
现实世界的一类事物:
属性:事物的状态信息。 行为:事物能够做什么。
Java中用class形容事物也是如此:
成员变量:对应事物的属性 成员方法:对应事物的行为
类的定义格式
public class ClassName {
//成员变量
//成员方法
}
- 定义类 :就是定义类的成员,包括成员变量和成员方法。
- 成员变量 :和以前定义变量几乎是一样的。只不过位置发生了改变。在类中,方法外。
- 成员方法 :和以前定义方法几乎是一样的。只不过把static去掉。
类的定义格式举例:
public class Student { //成员变量 String name;//姓名 int age;//年龄 //成员方法 //学习的方法 publicvoid study() { System.out.println("好好学习,天天向上"); } //吃饭的方法 publicvoid eat() { System.out.println("学习饿了要吃饭"); }}1.4 对象的使用
对象的使用格式
创立对象:
类名 对象名 = new 类名();
使用对象访问类中的成员:
对象名.成员变量;
对象名.成员方法();
对象的使用格式举例:
public class Test01_Student { public static void main(String[] args) { //创立对象格式:类名 对象名 = new 类名(); Student s = new Student(); System.out.println("s:"+s); //cn.itcast.Student@100363 //直接输出成员变量值 System.out.println("姓名:"+s.name); //null System.out.println("年龄:"+s.age); //0 System.out.println("‐‐‐‐‐‐‐‐‐‐"); //给成员变量赋值 s.name = "赵丽颖"; s.age = 18; //再次输出成员变量的值 System.out.println("姓名:"+s.name); //赵丽颖 System.out.println("年龄:"+s.age); //18 System.out.println("‐‐‐‐‐‐‐‐‐‐"); //调用成员方法 s.study(); // "好好学习,天天向上" s.eat(); // "学习饿了要吃饭" }}成员变量的默认值

1.5 类与对象的练习
定义手机类:
public class Phone { // 成员变量 String brand; //品牌 int price; //价格 String color; //颜色 // 成员方法 //打电话 public void call(String name) { System.out.println("给"+name+"打电话"); } //发短信 public void sendMessage() { System.out.println("群发短信"); }}定义测试类:
public class Test02Phone { public static void main(String[] args) { //创立对象 Phone p = new Phone(); //输出成员变量值 System.out.println("品牌:"+p.brand);//null System.out.println("价格:"+p.price);//0 System.out.println("颜色:"+p.color);//null System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐"); //给成员变量赋值 p.brand = "锤子"; p.price = 2999; p.color = "棕色"; //再次输出成员变量值 System.out.println("品牌:"+p.brand);//锤子 System.out.println("价格:"+p.price);//2999 System.out.println("颜色:"+p.color);//棕色 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐"); //调用成员方法 p.call("紫霞"); p.sendMessage(); }}1.6 对象内存图
一个对象,调用一个方法内存图

两个对象,调用同一方法内存图

一个引用,作为参数传递到方法中内存图

1.7 成员变量和局部变量区别
变量根据定义位置的不同,我们给变量起了不同的名字。如下图所示:

- 在类中的位置不同
- 成员变量:类中,方法外
- 局部变量:方法中或者者方法公告上 (形式参数)
- 作用范围不一样
- 成员变量:类中
- 局部变量:方法中
- 初始化值的不同
- 成员变量:有默认值
- 局部变量:没有默认值。必需先定义,赋值,最后使用
- 在内存中的位置不同
- 成员变量:堆内存
- 局部变量:栈内存
- 生命周期不同
- 成员变量:随着对象的创立而存在,随着对象的消失而消失
- 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
2. 封装
2.1 封装概述
概述
面向对象编程语言是对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。封装可以被认为是一个保护屏障,防止该类的代码和数据被其余类随便访问。要访问该类的数据,必需通过指定的方式。适当的封装可以让代码更容易了解与维护,也增强了代码的安全性。
准则
将属性隐藏起来,若需要访问某个属性,提供公共方法对其访问。
2.2 封装的步骤
- 使用 private 关键字来修饰成员变量。
- 对需要访问的成员变量,提供对应的一对 getXxx 方法 、 setXxx 方法。
2.3 封装的操作——private关键字
private的含义
- private是一个权限修饰符,代表最小权限。
- 可以修饰成员变量和成员方法。
- 被private修饰后的成员变量和成员方法,只在本类中才能访问。
private的使用格式
private 数据类型 变量名 ;
- 使用 private 修饰成员变量,代码如下:
public class Student { private String name; private int age;}- 提供 getXxx 方法 / setXxx 方法,可以访问成员变量,代码如下:
public class Student { private String name; private int age; public void setName(String n) { name = n; } public String getName() { return name; } public void setAge(int a) { age = a; } public int getAge() { return age; }}2.4 封装优化1——this关键字
我们发现 setXxx 方法中的形参名字并不符合见名知意的规定,那么假如修改与成员变量名一致,能否就见名知意了呢?代码如下:
public class Student { private String name; private int age; public void setName(String name) { name = name; } public void setAge(int age) { age = age; }}经过修改和测试,我们发现新的问题,成员变量赋值失败了。也就是说,在修改了 setXxx() 的形参变量名后,方法并没有给成员变量赋值!这是因为形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无法访问到成员变量,从而赋值失败。所以,我们只能使用this关键字,来处理这个重名问题。
this的含义
this代表所在类的当前对象的引用(地址值),即对象自己的引用。
记住 :方法被哪个对象调用,方法中的this就代表那个对象。即谁在调用,this就代表谁。
this使用格式
this.成员变量名;使用 this 修饰方法中的变量,处理成员变量被隐藏的问题,代码如下:
public class Student { private String name; private int age; public void setName(String name) { //name = name; this.name = name; } public String getName() { return name; } public void setAge(int age) { //age = age; this.age = age; } public int getAge() { return age; }}小贴士:方法中只有一个变量名时,默认也是使用 this 修饰,可以省略不写。
2.5 封装优化2——构造方法
当一个对象被创立时候,构造方法用来初始化该对象,给对象的成员变量赋初始值。
小贴士:无论你与否自己设置构造方法,所有的类都有构造方法,由于Java自动提供了一个无参数构造方法,一旦自己定义了构造方法,Java自动提供的默认无参数构造方法就会失效。
构造方法的定义格式
修饰符 构造方法名(参数列表){// 方法体 }构造方法的写法上,方法名与它所在的类名相同。它没有返回值,所以不需要返回值类型,甚至不需要void。使用构造方法后,代码如下:
public class Student { private String name; private int age; // 无参数构造方法 public Student() {} // 有参数构造方法 public Student(String name,int age) { this.name = name; this.age = age; }}注意事项
- 假如你不提供构造方法,系统会给出无参数构造方法。
- 假如你提供了构造方法,系统将不再提供无参数构造方法。
- 构造方法是可以重载的,既可以定义参数,也可以不定义参数。
2.6 标准代码——JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类,要求类必需是具体的和公共的,并且具备无参数的构造方法,提供用来操作成员变量的 set 和 get 方法。
public class ClassName{ //成员变量 //构造方法 //无参构造方法【必需】 //有参构造方法【建议】 //成员方法 //getXxx() //setXxx()}编写符合 JavaBean 规范的类,以学生类为例,标准代码如下:
public class Student { //成员变量 private String name; private int age; //构造方法 public Student() {} public Student(String name,int age) { this.name = name; this.age = age; } //成员方法 publicvoid setName(String name) { this.name = name; } public String getName() { return name; } publicvoid setAge(int age) { this.age = age; } publicint getAge() { return age; }}测试类,代码如下:
public class TestStudent { public static void main(String[] args) { //无参构造使用 Student s= new Student(); s.setName("柳岩"); s.setAge(18); System.out.println(s.getName()+"‐‐‐\"+s.getAge()); //带参构造使用 Student s2= new Student("赵丽颖",18); System.out.println(s2.getName()+"‐‐‐\"+s2.getAge()); }}3.代码
3.1
import java.util.Arrays;/*面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细解决每一个细节。面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具备该功能的人,来帮我做事儿。 */public class Demo01PrintArray { public static void main(String[] args) { int[] array = { 10, 20, 30, 40, 50, 60 }; // 要求打印格式为:[10, 20, 30, 40, 50] // 使用面向过程,每一个步骤细节都要亲力亲为。 System.out.print("["); for (int i = 0; i < array.length; i++) { if (i == array.length - 1) { // 假如是最后一个元素 System.out.println(array[i] + "]"); } else { // 假如不是最后一个元素 System.out.print(array[i] + ", "); } } System.out.println("=============="); // 使用面向对象 // 找一个JDK给我们提供好的Arrays类, // 其中有一个toString方法,直接就能把数组变成想要的格式的字符串 System.out.println(Arrays.toString(array)); }}/*通常情况下,一个类并不能直接使用,需要根据类创立一个对象,才能使用。1. 导包:也就是指出需要使用的类,在什么位置。import 包名称.类名称;import cn.itcast.day06.demo01.Student;对于和当前类属于同一个包的情况,可以省略导包语句不写。2. 创立,格式:类名称 对象名 = new 类名称();Student stu = new Student();3. 使用,分为两种情况:使用成员变量:对象名.成员变量名使用成员方法:对象名.成员方法名(参数)(也就是,想用谁,就用对象名点儿谁。)注意事项:假如成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。 */public class Demo02Student { public static void main(String[] args) { // 1. 导包。 // 我需要使用的Student类,和我自己Demo02Student位于同一个包下,所以省略导包语句不写 // 2. 创立,格式: // 类名称 对象名 = new 类名称(); // 根据Student类,创立了一个名为stu的对象 Student stu = new Student(); // 3. 使用其中的成员变量,格式: // 对象名.成员变量名 System.out.println(stu.name); // null System.out.println(stu.age); // 0 System.out.println("============="); // 改变对象当中的成员变量数值内容 // 将右侧的字符串,赋值交给stu对象当中的name成员变量 stu.name = "赵丽颖"; stu.age = 18; System.out.println(stu.name); // 赵丽颖 System.out.println(stu.age); // 18 System.out.println("============="); // 4. 使用对象的成员方法,格式: // 对象名.成员方法名() stu.eat(); stu.sleep(); stu.study(); }}/*定义一个类,用来模拟“学生”事物。其中就有两个组成部分:属性(是什么): 姓名 年龄行为(能做什么): 吃饭 睡觉 学习对应到Java的类当中:成员变量(属性): String name; // 姓名 int age; // 年龄成员方法(行为): public void eat() {} // 吃饭 public void sleep() {} // 睡觉 public void study() {} // 学习注意事项:1. 成员变量是直接定义在类当中的,在方法外边。2. 成员方法不要写static关键字。 */public class Student { // 成员变量 String name; // 姓名 int age; // 姓名 // 成员方法 public void eat() { System.out.println("吃饭饭!"); } public void sleep() { System.out.println("睡觉觉!"); } public void study() { System.out.println("学习!"); }}3.2
/*定义一个类,用来模拟“手机”事物。属性:品牌、价格、颜色行为:打电话、发短信对应到类当中:成员变量(属性): String brand; // 品牌 double price; // 价格 String color; // 颜色成员方法(行为): public void call(String who) {} // 打电话 public void sendMessage() {} // 群发短信 */public class Phone { // 成员变量 String brand; // 品牌 double price; // 价格 String color; // 颜色 // 成员方法 public void call(String who) { System.out.println("给" + who + "打电话"); } public void sendMessage() { System.out.println("群发短信"); }}public class Demo01PhoneOne { public static void main(String[] args) { // 根据Phone类,创立一个名为one的对象 // 格式:类名称 对象名 = new 类名称(); Phone one = new Phone(); System.out.println(one.brand); // null System.out.println(one.price); // 0.0 System.out.println(one.color); // null System.out.println("========="); one.brand = "苹果"; one.price = 8388.0; one.color = "黑色"; System.out.println(one.brand); // 苹果 System.out.println(one.price); // 8388.0 System.out.println(one.color); // 黑色 System.out.println("========="); one.call("乔布斯"); // 给乔布斯打电话 one.sendMessage(); // 群发短信 }}public class Demo02PhoneTwo { public static void main(String[] args) { Phone one = new Phone(); System.out.println(one.brand); // null System.out.println(one.price); // 0.0 System.out.println(one.color); // null System.out.println("========="); one.brand = "苹果"; one.price = 8388.0; one.color = "黑色"; System.out.println(one.brand); // 苹果 System.out.println(one.price); // 8388.0 System.out.println(one.color); // 黑色 System.out.println("========="); one.call("乔布斯"); // 给乔布斯打电话 one.sendMessage(); // 群发短信 System.out.println("========="); Phone two = new Phone(); System.out.println(two.brand); // null System.out.println(two.price); // 0.0 System.out.println(two.color); // null System.out.println("========="); two.brand = "三星"; two.price = 5999.0; two.color = "蓝色"; System.out.println(two.brand); // 三星 System.out.println(two.price); // 5999.0 System.out.println(two.color); // 蓝色 System.out.println("========="); two.call("欧巴"); // 给欧巴打电话 two.sendMessage(); // 群发短信 }}public class Demo03PhoneSame { public static void main(String[] args) { Phone one = new Phone(); System.out.println(one.brand); // null System.out.println(one.price); // 0.0 System.out.println(one.color); // null System.out.println("========="); one.brand = "苹果"; one.price = 8388.0; one.color = "黑色"; System.out.println(one.brand); // 苹果 System.out.println(one.price); // 8388.0 System.out.println(one.color); // 黑色 System.out.println("========="); one.call("乔布斯"); // 给乔布斯打电话 one.sendMessage(); // 群发短信 System.out.println("========="); // 将one当中保存的对象地址值赋值给two Phone two = one; System.out.println(two.brand); // 苹果 System.out.println(two.price); // 8388.0 System.out.println(two.color); // 黑色 System.out.println("========="); two.brand = "三星"; two.price = 5999.0; two.color = "蓝色"; System.out.println(two.brand); // 三星 System.out.println(two.price); // 5999.0 System.out.println(two.color); // 蓝色 System.out.println("========="); two.call("欧巴"); // 给欧巴打电话 two.sendMessage(); // 群发短信 }}public class Demo04PhoneParam { public static void main(String[] args) { Phone one = new Phone(); one.brand = "苹果"; one.price = 8388.0; one.color = "土豪金"; method(one); // 传递进去的参数其实就是地址值 } public static void method(Phone param) { System.out.println(param.brand); // 苹果 System.out.println(param.price); // 8388.0 System.out.println(param.color); // 土豪金 }}public class Demo05PhoneReturn { public static void main(String[] args) { Phone two = getPhone(); System.out.println(two.brand); // 苹果 System.out.println(two.price); // 8388.0 System.out.println(two.color); // 玫瑰金 } public static Phone getPhone() { Phone one = new Phone(); one.brand = "苹果"; one.price = 8388.0; one.color = "玫瑰金"; return one; }}3.3
/*问题形容:定义Person的年龄时,无法阻止不正当的数值被设置进来。处理方案:用private关键字将需要保护的成员变量进行修饰。一旦使用了private进行修饰,那么本类当中依然可以随便访问。但是!超出了本类范围之外就不能再直接访问了。间接访问private成员变量,就是定义一对儿Getter/Setter方法必需叫setXxx或者者是getXxx命名规则。对于Getter来说,不能有参数,返回值类型和成员变量对应;对于Setter来说,不能有返回值,参数类型和成员变量对应。 */public class Person { String name; // 姓名 private int age; // 年龄 public void show() { System.out.println("我叫:" + name + ",年龄:" + age); } // 这个成员方法,专门用于向age设置数据 public void setAge(int num) { if (num < 100 && num >= 9) { // 假如是正当情况 age = num; } else { System.out.println("数据不正当!"); } } // 这个成员方法,专门私语获取age的数据 public int getAge() { return age; }}/*对于基本类型当中的boolean值,Getter方法肯定要写成isXxx的形式,而setXxx规则不变。 */public class Student { private String name; // 姓名 private int age; // 年龄 private boolean male; // 是不是爷们儿 public void setMale(boolean b) { male = b; } public boolean isMale() { return male; } public void setName(String str) { name = str; } public String getName() { return name; } public void setAge(int num) { age = num; } public int getAge() { return age; }}/*局部变量和成员变量1. 定义的位置不一样【重点】局部变量:在方法的内部成员变量:在方法的外部,直接写在类当中2. 作用范围不一样【重点】局部变量:只有方法当中才可以使用,出了方法就不能再用成员变量:整个类全都可以通用。3. 默认值不一样【重点】局部变量:没有默认值,假如要想使用,必需手动进行赋值成员变量:假如没有赋值,会有默认值,规则和数组一样4. 内存的位置不一样(理解)局部变量:位于栈内存成员变量:位于堆内存5. 生命周期不一样(理解)局部变量:随着方法进栈而诞生,随着方法出栈而消失成员变量:随着对象创立而诞生,随着对象被垃圾回收而消失 */public class Demo01VariableDifference { String name; // 成员变量 public void methodA() { int num = 20; // 局部变量 System.out.println(num); System.out.println(name); } public void methodB(int param) { // 方法的参数就是局部变量 // 参数在方法调用的时候,必然会被赋值的。 System.out.println(param); int age; // 局部变量// System.out.println(age); // 没赋值不能用// System.out.println(num); // 错误写法! System.out.println(name); }}/*面向对象三大特征:封装、继承、多态。封装性在Java当中的表现:1. 方法就是一种封装2. 关键字private也是一种封装封装就是将少量细节信息隐藏起来,对于外界不可见。 */public class Demo02Method { public static void main(String[] args) { int[] array = {5, 15, 25, 20, 100}; int max = getMax(array); System.out.println("最大值:" + max); } // 给我一个数组,我还给你一个最大值 public static int getMax(int[] array) { int max = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] > max) { max = array[i]; } } return max; }}public class Demo03Person { public static void main(String[] args) { Person person = new Person(); person.show(); person.name = "赵丽颖";// person.age = -20; // 直接访问private内容,错误写法! person.setAge(20); person.show(); }}public class Demo04Student { public static void main(String[] args) { Student stu = new Student(); stu.setName("鹿晗"); stu.setAge(20); stu.setMale(true); System.out.println("姓名:" + stu.getName()); System.out.println("年龄:" + stu.getAge()); System.out.println("是不是爷们儿:" + stu.isMale()); }}3.4
/*当方法的局部变量和类的成员变量重名的时候,根据“就近准则”,优先使用局部变量。假如需要访问本类当中的成员变量,需要使用格式:this.成员变量名“通过谁调用的方法,谁就是this。” */public class Person { String name; // 我自己的名字 // 参数name是对方的名字 // 成员变量name是自己的名字 public void sayHello(String name) { System.out.println(name + ",你好。我是" + this.name); System.out.println(this); }}/*构造方法是专门用来创立对象的方法,当我们通过关键字new来创立对象时,其实就是在调用构造方法。格式:public 类名称(参数类型 参数名称) { 方法体}注意事项:1. 构造方法的名称必需和所在的类名称完全一样,就连大小写也要一样2. 构造方法不要写返回值类型,连void都不写3. 构造方法不能return一个具体的返回值4. 假如没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数、方法体什么事情都不做。public Student() {}5. 一旦编写了至少一个构造方法,那么编译器将不再赠送。6. 构造方法也是可以进行重载的。重载:方法名称相同,参数列表不同。 */public class Student { // 成员变量 private String name; private int age; // 无参数的构造方法 public Student() { System.out.println("无参构造方法执行啦!"); } // 全参数的构造方法 public Student(String name, int age) { System.out.println("全参构造方法执行啦!"); this.name = name; this.age = age; } // Getter Setter public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; }}public class Demo01Person { public static void main(String[] args) { Person person = new Person(); // 设置我自己的名字 person.name = "王健林"; person.sayHello("王思聪"); System.out.println(person); // 地址值 }}public class Demo02Student { public static void main(String[] args) { Student stu1 = new Student(); // 无参构造 System.out.println("============"); Student stu2 = new Student("赵丽颖", 20); // 全参构造 System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); // 假如需要改变对象当中的成员变量数据内容,依然还需要使用setXxx方法 stu2.setAge(21); // 改变年龄 System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); }}3.5
/*一个标准的类通常要拥有下面四个组成部分:1. 所有的成员变量都要使用private关键字修饰2. 为每一个成员变量编写一对儿Getter/Setter方法3. 编写一个无参数的构造方法4. 编写一个全参数的构造方法这样标准的类也叫做Java Bean */public class Student { private String name; // 姓名 private int age; // 年龄 public Student() { } public Student(String name, int age) { this.name = name; this.age = 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; }}public class Demo01Student { public static void main(String[] args) { Student stu1 = new Student(); stu1.setName("迪丽热巴"); stu1.setAge(20); System.out.println("姓名:" + stu1.getName() + ",年龄:" + stu1.getAge()); System.out.println("================="); Student stu2 = new Student("古力娜扎", 21); System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); stu2.setAge(22); System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); }}1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 类与对象、封装、构造方法