面向对象思想
面向对象思想概述
1、概述
Java语言是一种面向对象的程序设计语言，而面向对象思想（OOP）是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想（POP），强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
2、面向对象与面向过程的区别
面向过程：POP: Process-Oriented Programming
以函数（方法）为最小单位
数据独立于函数之外
以过程，步骤为主，考虑怎么做
面向对象：OOP: Object Oriented Programming
以类/对象为最小单位，类包括：数据+方法
以对象（谁）为主，考虑谁来做，谁能做
面向对象仍然包含面向过程，只不过关注点变了，关注谁来做
程序员的角色：
面向过程：程序员是具体执行者
面向对象：程序员是指挥者
面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。
例子：把大象装进冰箱
3、面向对象的基本特征
面向对象的语言中，包含了三大基本特征，即封装、继承和多态。
类和对象
环顾周围，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人类。那么什么是类呢？什么是对象呢？
什么是类
-
类：是一类具有相同特性的事物的抽象描述，是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
现实中，描述一类事物：
-
属性：就是该事物的状态信息。
-
行为：就是该事物能够做什么。
举例：小猫。
属性：名字、体重、年龄、颜色。 行为：走、跑、叫。
什么是对象
-
对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。
现实中，一类事物的一个实例：一只小猫 。
举例：一只小猫。
属性：tom、5kg、2 years、yellow。 行为：溜墙根走、蹦跶的跑、喵喵叫。
类与对象的关系
-
类是对一类事物的描述，是抽象的。
-
对象是一类事物的实例，是具体的。
-
类是对象的模板，对象是类的实体。
类的定义和对象的创建
事物与类的对比
现实世界的一类事物：
属性：事物的状态信息。 行为：事物能够做什么。
Java中用class描述事物也是如此：
成员变量：对应事物的属性 成员方法：对应事物的行为
类的定义格式
public class ClassName {
//成员变量
//成员方法
}-
定义类：就是定义类的成员，包括成员变量和成员方法。
-
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
-
成员方法：和以前写的main方法格式类似。只不过功能和形式更丰富了。在类中，方法外。
类的定义格式举例：
public class Person {
//成员变量
String name；//姓名
int age；//年龄
boolean isMarried;
public void walk(){
System.out.println("人走路...");
}
public String display(){
return "名字是：" + name + "，年龄是：" + age + "，Married：" + isMarried;
}
}
对象的创建
创建对象：
new 类名()//也称为匿名对象
//给创建的对象命名
//或者说，把创建的对象用一个引用数据类型的变量保存起来
类名 对象名 = new 类名();
类似于：
System.out.println("柴老师年龄是：" + 18);//如果确定只在这里一次性使用，那么可以不用变量保存(#^.^#)
//把18用int类型的age变量保存起来，方便后面使用
int age = 18;
System.out.println("柴老师年龄是：" + age);
System.out.println("宋老师比柴老师大10岁，年龄是：" + (age+10));
那么，对象名中存储的是什么呢？答：对象地址
class Student{
}
public class TestStudent{
//Java程序的入口
public static void main(String[] args){
System.out.println(new Student());//Student@7852e922
Student stu = new Student();
System.out.println(stu);//Student@4e25154f
int[] arr = new int[5];
System.out.println(arr);//[I@70dea4e
}
}
//Student和TestStudent没有位置要求，谁在上面谁在下面都可以
//但是如果TestStudent类的main中使用了Student类，那么要求编译时，这个Student已经写好了，不写是不行的
//如果两个类都在一个.java源文件中，只能有一个类是public的
发现学生对象和数组对象类似，直接打印对象名和数组名都是显示“类型@对象的hashCode值"，所以说类、数组都是引用数据类型，引用数据类型的变量中存储的是对象的地址，或者说指向堆中对象的首地址。
成员变量
1、成员变量的分类
实例变量：也叫对象属性，属于某个对象的，通过对象来使用
类变量：也叫类变量，属于整个类的，不是属于某个实例，后面static部分讲解。
2、如何声明实例变量？
【修饰符】 class 类名{
【修饰符】 数据类型 属性名; //属性有默认值
【修饰符】 数据类型 属性名 = 值; //属性有初始值
}
说明：属性的类型可以是Java的任意类型，包括基本数据类型、引用数据类型（类、接口、数组等）
3、如何使用实例变量？
（1）实例变量在本类的实例方法中，直接使用。
class Circle{
double radius;
public double getArea(){
return 3.14 * radius * radius;
}
}
（2）实例变量在其他类的方法中，需要通过“对象名.实例变量"的方式使用
public class TestCircle{
public static void main(String[] args){
Circle c = new Circle();
System.out.println("c这个圆的半径是：" + c.radius);
//修改c这个圆的半径
c.radius = 1.2;
System.out.println("c这个圆的半径是：" + c.radius);
}
}
4、实例变量的特点
（1）成员变量的默认值
| 基本类型 | 整数（byte，short，int，long） | 0 |
|---|---|---|
| 浮点数（float，double） | 0.0 | |
| 字符（char） | '\u0000' | |
| 布尔（boolean） | false | |
| 数据类型 | 默认值 | |
| 引用类型 | 数组，类，接口 | null |
（2）实例变量的值是每个对象独立的
class Circle{
double radius;
}
public class TestCircle{
public static void main(String[] args){
Circle c1 = new Circle();
Circle c2 = new Circle();
System.out.println("c1这个圆的半径是：" + c1.radius);//0.0
System.out.println("c2这个圆的半径是：" + c2.radius);//0.0
//修改c1这个圆的半径的值
c1.radius = 1.2;
System.out.println("c1这个圆的半径是：" + c1.radius);//1.2
System.out.println("c2这个圆的半径是：" + c2.radius);//0.0
}
}
5、如何给实例变量赋值？
（1）在声明属性时显式赋值，那么每一个对象创建之后，这个属性就不是默认值，而是这个初始值了
【修饰符】 class 类名{
【修饰符】 数据类型 属性名 = 值; //属性有初始值
}
代码示例：
class Student{
String name;
char gender = '男';//显式赋值
}class TestStudent{
public static void main(String[] args){
Student s1 = new Student();
System.out.println("姓名：" + s1.name);//null
System.out.println("性别：" + s1.gender);//男
s1.name = "小薇";//修改属性的默认值
s1.gender = '女';//修改属性的初始值
System.out.println("姓名：" + s1.name);//小薇
System.out.println("性别：" + s1.gender);//女
Student s2 = new Student();
System.out.println("姓名：" + s2.name);//null
System.out.println("性别：" + s2.gender);//男
}
}
（2）通过对象为属性赋值
//为对象的属性赋值
对象名.属性名 = 值;
6、实例变量内存图
class Student{
String name;
char gender = '男';//显式赋值
}
class TestStudent{
public static void main(String[] args){
Student s1 = new Student();
System.out.println("姓名：" + s1.name);//null
System.out.println("性别：" + s1.gender);//男
s1.name = "小薇";
s1.gender = '女';
System.out.println("姓名：" + s1.name);//小薇
System.out.println("性别：" + s1.gender);//女
Student s2 = new Student();
System.out.println("姓名：" + s2.name);//null
System.out.println("性别：" + s2.gender);//男
}
}
7、实例变量和局部变量区别
变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：
-
在类中的位置不同
重点-
实例变量：类中，方法外
-
局部变量：方法中或者方法声明上(形式参数)
-
-
作用范围不一样
重点-
实例变量：类中直接用，其他类通过"对象名.实例变量"使用
-
局部变量：当前方法的作用域中
-
-
初始化值的不同
重点-
实例变量：有默认值
-
局部变量：没有默认值。必须先定义，赋值，最后使用
-
-
在内存中的位置不同
了解-
实例变量：堆内存
-
局部变量：栈内存
-
-
生命周期不同
了解-
实例变量：随着对象的创建或者类的加载而存在，随着对象的消失而消失
-
换句话说，没有创建对象，就不会在堆中分配它的内存，创建一个，分配一个
-
-
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
-
换句话说，方法没有被调用，该局部变量不会在栈中分配内存，调用一次，分配一次
-
-
成员方法
方法的概念
方法也叫函数，是一个独立功能的定义，是一个类中最基本的功能单元。
把一个功能封装为方法的目的是，可以实现代码重用，从而简少代码量。
方法的原则
方法的使用原则：
（1）必须先声明后使用
类，变量，方法等都要先声明后使用
（2）不调用不执行，调用一次执行一次。调用一次，在栈中压入一个方法栈。
成员方法的分类
成员方法分为两类：
-
实例方法：属于对象的方法，由对象来调用。
-
静态方法：也叫类方法，属于整个类的，不是属于某个实例，由类名来调用，后面static部分讲解。
定义实例方法的格式详解
1、语法格式
修饰符 返回值类型 方法名(【参数列表：参数类型1 参数名1,参数类型2 参数名, ...... 】){
方法体；
【return 返回值;】
}
-
修饰符： public 目前固定写法，没有学习其他修饰符
-
返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
-
基本数据类型
-
引用数据类型
-
无返回值类型：void
-
-
方法名：给方法起一个名字，见名知意，能准确代表该方法功能的名字
-
参数列表：方法内部需要用到其他方法中的数据，需要通过参数传递的形式将数据传递过来，可以是基本数据类型、引用数据类型、也可以没有参数，什么都不写
-
方法体：特定功能代码
-
return：结束方法，并将方法的结果返回去，
-
如果返回值类型不是void，方法体中必须保证一定有return 返回值;语句，并且要求该返回值结果的类型与声明的返回值类型一致或兼容。
-
如果返回值类型为void时，return 后面不用跟返回值，甚至也可以没有return语句。
-
return语句后面就不能再写其他代码了，否则会报错：Unreachable code
-
2、方法声明的位置必须在类中方法外
正确示例：
类{ 方法1(){ } 方法2(){ } }错误示例：
类{ 方法1(){ 方法2(){ //错误 } } }
实例方法调用
-
方法调用的位置：在另一个方法中调用。
正确示例：
类{ 方法1(){ 调用其他方法; } } -
方法调用的分类：
-
单独调用，格式如下：
对象名.方法名(参数)；
-
输出或返回调用，格式如下：
-
-
System.out.println(对象名.方法名(参数));//直接输出方法调用后的返回值 或 return 对象名.方法名(参数);//直接返回方法调用后的返回值作为当前方法的返回值
-
赋值调用，格式如下：
数据类型 变量名 = 对象名.方法名(参数)；
如果实例方法是在本类的另一个实例方法中调用，那么可以省略“对象名.”
class Count {
/*
定义计算两个整数和的方法
返回值类型，计算结果是int
参数：不确定数据求和，定义int参数.参数又称为形式参数
*/
public int getSum(int a, int b) {
return a + b;
}
/*
定义计算两个整数差的方法
返回值类型，计算结果是int
参数：不确定数据求差，定义int参数.参数又称为形式参数
*/
public int getSubtract(int a, int b){
return getSum(a,-b);//直接返回getSum(a,-b)方法调用的结果作为getSubtract(a,b)的结果
}
}
public class Method_Demo1 {
public static void main(String[] args) {
// 创建对象
Count c = new Count();
// 通过单独调用方式调用方法
c.getSum(3,4)；
// 通过输出调用方式调用方法
System.out.println(c.getSum(3,4));
// 通过赋值调用方式调用方法
int sum = c.getSum(3,4)；
System.out.println(sum);
}
}-
形参：在定义方法时方法名后面括号中的变量名称称为形式参数（简称形参），即形参出现在方法定义中。
-
实参：调用者方法中调用另一个方法时，方法名后面括号中的参数称为实际参数（简称实参），即实参出现在调用者方法中。
总结：
（1）调用时，需要通过方法名来识别调用哪个方法
（2）调用时，需要传“实参”，实参的个数、类型、顺序顺序要与形参列表一一对应
如果方法没有形参，就不需要也不能传实参。
（3）调用时，如果方法有返回值，可以接受或处理返回值结果。
如果方法的返回值类型是void，不需要也不能接收和处理返回值结果。
方法调用内存分析
方法不调用不执行，调用一次执行一次，每次调用会在栈中有一个入栈动作，即给当前方法开辟一块独立的内存区域，用于存储当前方法的局部变量的值，当方法执行结束后，会释放该内存，称为出栈，如果方法有返回值，就会把结果返回调用处，如果没有返回值，就直接结束，回到调用处继续执行下一条指令。
栈结构：先进后出，后进先出。
class Test18_Invoke_Memory{
public static void main(String[] args){
Count c = new Count();
int x = 1;
int y = 2;
int sum = c.getSum(x,y);
System.out.println(x + " + " + y + " = " + sum);
}
}
class Count{
public int getSum(int a, int b){
return a + b;
}
}
1111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
