大数据必学Java基础（三十三）：面向对象介绍
面向对象介绍
一、面向过程和面向对象的区别
面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，以函数为最小单位，考虑怎么做。
面向对象：注重找“参与者”,将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
案例：
人把大象装进冰箱：
面向过程：
函数1：打开冰箱(){人站在冰箱前，打开冰箱，冰箱卡到30度角的时候，冰箱的灯打开了.........}
函数2：储存大象(){大象先迈左腿，再迈右退，考虑冰箱能不能装下......}
函数3：关闭冰箱(){人站在冰箱前，关闭冰箱，冰箱开到30度角的时候，冰箱的灯关闭了..........}
面向对象：
人{
打开(冰箱){
冰箱.打开();
}
存储(大象){
大象.进入();
}
关闭(冰箱){
冰箱.关闭();
}
}
冰箱{
打开（）{ 1.2.3.}
关闭（）{}
}
柜子{
}
大象{
进入(冰箱){
}
}
面向过程 ---> 面向对象 , 其实就是由执行者 ---> 指挥者的 一个过渡
面向过程：编年体 面向对象：纪传体
二者相辅相成,并不是对立的。解决复杂问题,通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统;具体到微观操作,仍然使用面向过程方式来处理
二、类和对象的关系
万事万物皆对象
对象：具体的事物，具体的实体，具体的实例，模板下具体的产品
类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板
一般在写代码的时候先写类，然后在根据类创建对应的对象。
三、面向对象三个阶段
【1】面向对象分析OOA -- Object Oriented Analysis
对象：张三，王五，朱六，你，我
抽取出一个类----》人类
类里面有什么：
动词--》动态特性--》方法
名词--》静态特性--》属性
【2】面向对象设计OOD -- Object Oriented Design
先有类，再有对象：
类：人类： Person
对象：zhangsan ，lisi，zhuliu
【3】面向对象编程OOP -- Object Oriented Programming
创建类：
（1）属性（field 成员变量）
属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
属性定义格式：
[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}
（2）方法
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法定义格式：
[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}
void代表没有返回值；方法的作用：重用代码，封装功能，便于修改
代码：
package com.lanson;
/**
* @Auther: lanson
* 创建类：人类
*/
public class Person {
//名词---》属性---》成员变量---》放在类中方法外（注意：我们只把有需要的内容写到代码里，不相关的东西不要放在代码中）
int age ;//年龄
String name;//姓名
double height;//身高
double weight;//体重
//动词---》方法
//吃饭
public void eat(){
int num = 10;//局部变量：放在方法中
System.out.println("我喜欢吃饭");
}
//睡觉：
public void sleep(String address){
System.out.println("我在"+address+"睡觉");
}
//自我介绍：
public String introduce(){
return "我的名字是："+name+"，我的年龄是："+age+",我的身高是："+height+",我的体重是："+weight;
}
}创建对象
package com.lanson;
/**
* @Auther: lanson
*/
public class Test {//测试类
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建一个人类的具体的对象/实例：
//创建一个对象，对象的名字叫：zs
//Person 属于 引用数据类型
//第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
Person zs = new Person();
zs.name = "张三";
zs.age = 19;
zs.height = 180.4;
zs.weight = 170.4;
//再创建一个对象：
//再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次
Person ls = new Person();
ls.name = "李四";
ls.age = 18;
ls.height = 170.6;
ls.weight = 160.5;
//对属性值进行读取：
System.out.println(zs.name);
System.out.println(ls.age);
//对方法进行操作：
//不同的对象，属性有自己的特有的值，但是方法都是调用类中通用的方法。
//属性：各个对象的属性是独立的，
//方法：各个对象的方法是共享的。
zs.eat();
ls.eat();
zs.sleep("教室");
/*String str = zs.introduce();
System.out.println(str);*/
System.out.println(zs.introduce());
}
}四、局部变量和成员变量的区别
区别1：代码中位置不同
成员变量：类中方法外定义的变量
局部变量：方法中定义的变量 代码块中定义的变量
区别2：代码的作用范围
成员变量：当前类的很多方法
局部变量：当前一个方法（当前代码块）
区别3：是否有默认值
成员变量：有
局部变量：没有
引用数据类型： null
区别4：是否要初始化
成员变量：不需要，不建议初始化，后续使用的时候再赋值即可
局部变量：一定需要，不然直接使用的时候报错
区别5：内存中位置不同
成员变量：堆内存
局部变量：栈内存
区别6：作用时间不同
成员变量：当前对象从创建到销毁
局部变量：当前方法从开始执行到执行完毕
代码：
package com.lanson;
/**
* @Auther: lanson
*/
public class Student {
byte e;
short s;
int c ;//成员变量：在类中方法外
long num2;
float f ;
double d;
char ch;
boolean bo;
String name;
public void study(){
int num = 10 ; //局部变量：在方法中
System.out.println(num);//10
//int num ;重复命名，出错了
{
int a;//局部变量：在代码块中
}
int a;
if(1==3){
int b;
}
System.out.println(c);
}
public void eat(){
System.out.println(c);
}
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.c);
System.out.println(s.bo);
System.out.println(s.ch);
System.out.println(s.d);
System.out.println(s.e);
System.out.println(s.f);
System.out.println(s.name);
System.out.println(s.num2);
System.out.println(s.s);
s.d = 10.4;
}
}运行结果：
五、构造器
package com.lanson;
/**
* @Auther: lanson
*/
public class Person {
//构造器：没有任何参数的构造器我们叫做：空参构造器--》空构造器
public Person(){
/*age = 19;
name = "lili";
height = 169.5;*/
}
//属性：
String name;
int age;
double height;
//方法：
public void eat(){
System.out.println("我喜欢吃饭");
}
}package com.lanson;
/**
* @Auther: lanson
*/
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建一个Person类的具体的对象/实例/实体：
/*
创建对象的过程：
1.第一次遇到Person的时候，进行类的加载（只加载一次）
2.创建对象，为这个对象在堆中开辟空间
3.为对象进行属性的初始化动作
new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
可以自己显式 的将构造器编写出来：
构造器的格式：
[修饰符] 构造器的名字(){
}
构造器和方法的区别：
1.没有方法的返回值类型
2.方法体内部不能有return语句
3.构造器的名字很特殊，必须跟类名一样
构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。
调用构造器的目的是给属性进行赋值操作的。
注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。
实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写
*/
Person p = new Person();
System.out.println(p.age);
System.out.println(p.name);
System.out.println(p.height);
Person p2 = new Person();
System.out.println(p2.age);
System.out.println(p2.name);
System.out.println(p2.height);
}
}六、构造器的重载
package com.lanson;
/**
* @Auther: lanson
*/
public class Person {
//属性：
String name;
int age;
double height;
//空构造器
public Person(){
}
public Person(String name,int age,double height){
//当形参名字和属性名字重名的时候，会出现就近原则：
//在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
this.name = name;
this.age = age;
this.height = height;
}
public Person(String a,int b){
name = a;
age = b;
}
//方法：
public void eat(){
System.out.println("我喜欢吃饭");
}
}/**
* @Auther: lanson
*/
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
/*
1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
2.一般我们会重载构造器，在重载的构造器中进行属性赋值操作
3.在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。
4. 当形参名字和属性名字重名的时候，会出现就近原则：
在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
*/
Person p = new Person();
/*p.age = 19;
p.name = "lili";
p.height = 180.4;*/
Person p2 = new Person("lili",19,180.4);
System.out.println(p2.age);
System.out.println(p2.height);
System.out.println(p2.name);
}
}- 点赞
- 收藏
- 关注作者
评论（0）