面向对象基础

面向对象基础

1、类和对象

1.1 对象：万物皆可是对象
1.2 面向对象：面向万物
1.3 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
类的特点：
(1) 类是对象的数据类型
(2) 类是具有相同属性和行为的一组对象的集合
1.4 对象的属性:
属性：对象具有的各种特性，每个对象的每个属性都有特定的值
1.5 对象的行为:
行为：对象能够执行的操作
1.6 类和对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得见摸得着的真实存在的实体
例如：
类对象
手机(Phone) 小米
华为
属性(成员变量)
品牌(Brand) ——》对象是类的实体化
价格(price)
…
行为（成员方法）
打电话(call) 《—— 类是对象的抽象
发短信(sendMessage)
…
1.7 类的定义
类的重要性：是Java程序的基本组成单位，必须先有类才能有对象
例如：必须现有手机这个抽象类才能有小米和华为实体的对象
类是什么：类是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会有的属性和行为
例如：手机这个抽象类都有的属性是品牌价格，行为是打电话发短信
类的组成：属性（成员变量）和行为（成员方法）
属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去挑static关键字即可）
类的定义步骤：
① 定义类 public class 类名{ ——》手机(Phone)
// 成员变量 ——》属性(成员变量）
变量1的数据类型变量1；品牌(Brand)
变量2的数据类型变量2；价格(price)
…
// 成员方法 ——》行为（成员方法）
方法1；打电话(call)
方法2；发短信(sendMessage)
… }
public class _Phone {
// 成员变量 _String brand;
_int _price;
// 成员方法 public void _getCall(){ System._out.println(“打电话”); }
public void _sendMessage(){ System._out.println(“发短信”); } }
1.8 类和对象
对象的使用:
创建对象
格式：类名对象名 = new 类名();
范例：Phone phone = new Phone();
使用对象
1、使用成员变量
格式：对象名，变量名
范例： phone .brand
2、使用成员方法
格式：对象名.方法名()
范例：phone .call()
// 因为要创建对象和适用对象所以需要main方法
public static void _main(String[] args) {
// 创建对象 _Phone phone = _new _Phone();
// 使用成员变量 -> 输出赋值前的默认值 _System._out.println(phone.brand); —> null
System.out.println(phone.price);—> 0
// 给成员对象赋值 phone.brand = “小米”;
phone.price = 2999;
// 使用成员变量 _System._out.println(phone.brand);—> 小米
System.out.println(phone.price);—> 2999
// 使用成员方法 _phone.getCall();—> 打电话
phone.sendMessage(); }—> 短信

控制台输出：null、0、小米、2999、打电话、发短信
对象输出的值都是类中定义好的，使用的方法也是类中自定义的
案例：学生
需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方的使用
思路：① 定义一个学生类
类名：Student
成员变量：name ，age
成员方法：study(),doHomework()
public class _Student {
String name ;
_int _age ;
_public void _study() {System._out.println(“学习”);}
public void _doHomework(){ System._out.println(“做作业”); } }
② 定义学生测试类
类命：StudentDemo
因为要做测试，所以有一个主方法：main方法
public class _StudentTest {
_public static void _main(String[] args) {
③ 给学生测试类中通过对象完成成员变量和成员方法的使用
给成员变量赋值，输出成员变量的值
调用成员方法
Student student = _new _Student();
System._out.println(student.age);
System.out.println(student.name);
student .age= “李畅”;
student .name= 26;
student.study();
student.doHomework(); } }

2、对象内存图

2.1 对象内存图(单个对象)
栈内存堆内存
方法：main 地址值：001
Studengt student new Student();
name 李畅
age 26
方法调用一旦结束从栈内存消失
方法：study()
调用者：student(001)
doHomework()
2.2 对象内存图(多个对象)
public class _StudentTest {
_public static void _main(String[] args) {
// 创建第一个对象，所有new出来的对象都有一个地址值占用堆内存
Student student1 = _new _Student();
System._out.println(student1.age);
System.out.println(student1.name);
student1 .age= “李畅”;
student1.name= 26;
student1.study();
student1.doHomework(); } }
// 创建第二个对象
Student student2 = new _Student();
student2 .age= “李四”;
student2.name= 28;
student2.study();
student2.doHomework(); } }
栈内存堆内存
方法：main 地址值：001
Studengt student1 new Student();
地址值：001 name 李畅
age 26
Studengt student2 地址值：002
地址值：002 new Student();
name 李四
age 28
2.3 对象内存图(多个对象指向相同的内存)
_public class _StudentTest {
_public static void _main(String[] args) {
// 创建第一个对象，所有new出来的对象都有一个地址值占用堆内存
Student student1 = _new _Student();
System._out.println(student1.age);
System.out.println(student1.name);
student1 .age= “李畅”;
student1.name= 26;
student1.study();
student1.doHomework(); } }
// 创建第二个对象把第一个对象的地址赋值给第二个对象
Student student2 = student1;
student2 .age= “李四”;
student2.name= 28;
student2.study();
student2.doHomework(); } }
栈内存堆内存
方法：main 地址值：001
Studengt student1 new Student();
地址值：001 name 李畅
age 26
Studengt student2 = student1 地址值：001
地址值：001 new Student();
name 李四
age 28

3、成员变量和局部变量

1、成员变量：类中方法外的变量
2、局部变量：方法中的变量
public class _Student {
// 成员变量 name，成员变量 age
String name ;
_int _age ;
_public void _study() {
// 局部变量 i，局部变量 j
int i = 0；j
System._out.println(“学习”);}
public void _doHomework(){
int j = 0；
System._out.println(“做作业”); } }
3、成员变量和局部变量的区别
区别成员变量局部变量
类中位置不同类中方法外方法内或者方法声明上
内存中位置不同堆内存栈内存
生命周期不同随着对象的存在而存在随着方法的调用而存在
随着对象的消失而消失随着方法的完毕而消失
初始化值不同有默认的初始化值没有初始化值，必须先定义，赋值
才能使用

4、封装

4.1 private关键字
1、是一个权限修饰符
2、可以修饰成员（成员变量和成员方法）
3、作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

private关键字相当于把类私有化，只能在这个类中使用，不能被对象使用，如果想要使用必须通过set和get
针对private修饰的成员变量，如果需要被其他类使用，需要提供相应的操作
1、提供”get变量名()”方法，用于获取成员变量的值，方法用public修饰
2、提供 “set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
3、”set变量名(参数)”方法的作用是赋值，”get变量名()”方法的作用是获取
// 学生类
public class _Student {
String name ;
// 封装类如果想让除了本类以外的外部对象调用需要提供get/set方法 private int _age;
private String name;
// set方法:set方法是需要设置值的传递一个int a的值
// 未来调用方法带参数将值赋值给a public void setAge(int _a){ // 在方法中进行年龄判断 if (a<0 || a>120){
System._out.println(“你是妖怪把”);
}else{ age = a; } };
// 未来调用方法带参数将值赋值给 n
public void _setName(String n) { name = n; }
// get方法:get方法是需要返回值的，返回的是一个int类型和String类型 public int _getAge(){ _return _age; }
public String getName() { _return _name; }
_public void _information() { System._out.println(“年龄 “+ age +”，姓名 “+ name); } }

// 学生测试类
public class _StudentTest {
_public static void _main(String[] args) {
Student student = _new _Student();
student.name = “李畅”;
// 调用封装类的方法setAge(int a); 并给参数a赋值
student.setAge(1);
student.information();
// 使用get方法获取成员变量的值System.out.println(student.getName() + “—-“ + student.getAge()); } }
4.2 this关键字
1、this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名，不带this修饰的变量值得是形参，而不是成员变量
方法的形参没有与成员变量同名，可以直接使用成员变量
*Tips：形参是自己定义方法中的参数(变量定义的格式例如int number)
实参是方法调用的参数(变量或者常量例如10 number)
2、什么时候使用this？
主要是为了解决形参和成员变量同名的情况出现，便会出现this修饰指定的成员变量
3、this 代表所在类的对象应用
记住：方法被哪个对象调用，this就代表哪个对象
4、this 内存原理
同理：方法被哪个对象调用就是指向哪个对象
方法setName 方法setName
参数： name:”凌青霞” 参数： name:”张曼玉”
调用者：是s1(001堆内存地址) 调用者：是s2(002堆内存地址)
this：指向s1 this：指向s2
public class _Student {
// String name 是该类的成员变量（类中方法外） private _String name;
_private int _age;
// String name 是该方法的局部变量（方法内或者方法声明上） public void _setName(String name) {
// 用this修饰的变量是成员变量是在方法外的，左边的name是局部变量
// 该操作将局部变量赋值给就是用this修饰过的成员变量 this.name = name; }

_public void _setAge(_int _age) { <br />     _// 用this修饰的变量age是成员变量 是在方法外的 ，左边的age是局部变量_<br />_   this_.age = age; }<br />    _public int _getAge() { _return _age; }<br />    _public _String getName() { _return _name; }<br />    _public void _information() {  System._out_.println("姓名:  " + name + ",年龄:  " + age);  }  }<br />4.3 封装概述：<br />封装 ：<br />1、是面向对象三大特征之一（封装、继承、多态）<br />     是面向对象编程语言对客观世界的模拟，客观世界里成员成员变量都是隐藏在对象内部的，外界是无法直接操作的<br />2、将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxxx()方法<br />3、封装的用处<br />通过方法来控制成员变量的操作，提高了代码的安全性<br />把代码用方法进行封装，提高了代码的复用性

5、构造方法

5.1 构造方法概述：
public class _StudentTest { _public static void _main(String[] args) { Student student = _new _Student(); } }
新建一个对象 Student student = _new _Student(); 带()小括号的是一个方法
但是这个方法比较特殊，是一个Student 类名的方法，所以Student()就是构造函数
构造方法是一种特殊的方法：
作用：创建对象
格式：public class 类名{ public class Student {
修饰符类名(参数){ // 没有参数，是无参的构造方法
构造方法内的内容 public Student() {
} }
} }
功能：主要是完成对象数据的初始化
如果这个类有成员变量的值，在构造方法中可以添加默认值。
创建一个对象，该对象最初需要有一个具体的值这个时候就有了构造方法
_public class _Phone{
// 成员变量 private _String brand;
_private int _price;
// 构造方法 public _Phone(){ System._out.println(“无参数构造方法”); }
public void _show(){ System._out.println(brand + “,” + price); } }
public class _PhoneTest {
// 因为要创建对象和适用对象所以需要main方法 public static void _main(String[] args) {
// 创建对象，因为上面的类中有构造方法，将对象数据初始化
// 对象就有了构造对象初始化的内容 _Phone phone = _new _Phone();
phone.show(); } }
5.2 构造方法注意事项：
构造方法的创建：
1、当类如果没有定义的构造方法，系统将自动分配一个无参数的构造方法
2、当类中定义了构造方法后，系统将不再分配无参数的构造方法
构造方法的重载
1、如果自定义了带参构造方法，还需要使用无参数构造方法，就必须再写一个无参数构造方法
2、无论是否使用无参构造方法，都手写一个无参数构造方法
3、构造方法可以给私有的成员变量赋值
4、构造方法类似重载，方法名相同参数不同
_public class _Phone{
// 成员变量 private _String brand;
_private int _price;
// 构造方法 public _Phone(){ System._out.println(“无参数构造方法”); }
// 带参构造方法，可以是一个可以是多个参数 public Phone(String brand,_int _price){
// 构造方法可以给私有的成员变量赋值 this.brand = brand;
this.price = price; }
public void _show(){ System._out.println(brand + “,” + price); } }

public class _PhoneTest {
// 因为要创建对象和适用对象所以需要main方法 public static void _main(String[] args) {
// 创建对象 _Phone phone = _new _Phone();
// 创建带多个参数的对象 _Phone phone1= _new _Phone(“小米”,30);
phone.show();
phone1.show(); } }
5.3 标准类制作
1、成员变量（类中方法外）
使用private修饰
2、构造方法
① 提供一个无参数构造方法
② 提供一个带多个参数的构造方法
3、成员方法
① 提供每一个成员变量对应的set()/get()方法
② 提供一个显示对象信息的show()方法
_public class _Phone{
// 成员变量 private _String brand;
_private int _price;
// 构造方法 public _Phone(){ System._out.println(“无参数构造方法”); }
// 带参构造方法，可以是一个可以是多个参数 public Phone(String brand,_int _price){
// 构造方法可以给私有的成员变量赋值 this.brand = brand;
this.price = price;
}
// 提供私有成员的成员方法get()/set() public String getBrand() { _return _brand; }
_public void _setBrand(String brand) { _this.brand = brand; }
public int _getPrice() { _return _price; }
_public void _setPrice(_int _price) { _this.price = price; }
// 提供成员的show()方法
public void _show(){ System._out.println(brand + “,” + price); } }
4、测试类制作的创建对象并为成员变量赋值的两种方式
① 无参构造方法创建对象后使用set()赋值
② 使用带参构造方法直接创建带有属性值的对象
public class _PhoneTest {
// 因为要创建对象和适用对象所以需要main方法 public static void _main(String[] args) {
// 无参构造方法创建对象 _Phone phone = _new _Phone();
// 使用set()方法赋值 _phone.setBrand(“华为”);
phone.setPrice(60);
// 使用get()方法返回set()方法赋成员变量的值
System._out.println(“手机品牌为:”+ phone.getBrand()+ “ “+”手机价格为:”+ phone.getPrice());
_// 创建带多个参数的对象
_Phone phone1= _new _Phone(“小米”,30);
phone1.show(); } }

JavaSE 学习笔记