1. 概述
- 面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲历亲为，详细处理每一个细节
- 面向对象：当需要实现一个功能的时候，不关心具体步骤，而是找一个已经具有该功能的人来帮我做事。
package cn.itcast.day05.demo01;
import java.util.Arrays;
public class Demo01PrintArray {
public static void main(String[] args) {
int[] array = {10,20,3,5,11,666};
//面向对象 打印数组
//JDK已经为我们提供了Arrays类，其中有一个是toString方法，直接就可以把数组变成想要的格式的字符串
System.out.println(Arrays.toString(array));
}
}
面向对象的语言中包含了3大特征：封装、继承、多态
2. 类和对象的关系
- 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类的事物。
- 类是对一类事物的描述
- 对象是一类事物的实例
- 类是对象的模板，对象是类的实体
2.1 类的定义
public class Student {
//成员变量（属性）：直接定义在类当中，在方法外面。
//之前所学的定义在方法(包括main方法)中的变量都是局部变量
String name;
String age;
//成员方法（行为）：与普通方法最显著的区别是没有关键字static
public void eat(){
System.out.println("吃饭饭");
}
public void sleep(){
System.out.println("吃觉觉");
}
public void study(){
System.out.println("学习！");
}
}
2.2 对象的创建及使用
/*
通常情况下 一个类并不可以直接使用，需要根据类创建一个对象，才可以使用
1. 导包：也就是指出需要使用的类在什么位置
import 包名称.类名称；
import cn.itcast.day05.demo01.Student
对于和当前类同属于一个包的情况，可以省略包语句不写
2. 创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student();
3. 使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名([参数])
注意事项：
如果成员变量没有赋值， 那么将会有一个默认值，规则和数组一样。
*/
public class Demo02Student {
public static void main(String[] args) {
//1. 导包 省略
//2. 创建对象
Student stu = new Student();
//3. 使用
System.out.println(stu.name);//null
System.out.println(stu.age);//0
//改变对象中成员变量的内容
stu.name = "赵丽颖";
stu.age = 18;
System.out.println(stu.name);//赵丽颖
System.out.println(stu.age);//18
//4. 使用对象的成员方法
stu.eat();
}
}
2.3 手机类练习
- 定义
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();
System.out.println(one.brand);
System.out.println(one.price);
System.out.println(one.color);
one.brand="苹果";
one.price=8388.5;
one.color="黑色";
System.out.println(one.brand);
System.out.println(one.price);
System.out.println(one.color);
one.call("乔布斯");
one.sendMessage();
}
}
2.4对象对应的内存图
- 方法区最先有数据，保存的是.class信息。两个.class相关信息都在方法区应该先从main方法开始执行。
- main方法进栈(压栈)，进栈之后做了一些事情：创建了一个对象（等号左边局部变量）Phone one。同时等号右边new Phone()在堆中开辟一段内存空间，并将其地址0x666，赋值给栈中的变量Phone one。
- 同时栈中new Phone()创建出的这个类里面所存放的内容由方法区告知(内容包括成员变量和成员方法)，将成员变量拿过来，并为其赋上默认值。而里面的成员方法保存的是一个地址值0x333。即成员方法的地址值保存在堆当中。
- 访问one.brand中的内容：通过one知道地址0x666,根据地址找到one.brand的当前值。
- 修改one.brand中的内容: 通过one知道地址0x666,根据地址找到one.brand的当前位置，并将其原先的值替换掉。
- 执行one.call("乔布斯")：通过one知道地址0x666，在根据0x333找到方法(两步走)，之后在方法区找到了一个call(String who)方法。
- 若想运行call(String who)方法，也需要进栈（注意：它是后进栈的，所以压着main方法，也叫压栈），之后根据参数“乔布斯”，得出给乔布斯打电话
- call(String who)方法该方法完成后，打上×，代表出栈，也叫弹栈。
- 之后运行one.sendMessage()，该方法进栈。。。出栈。。。
- main方法出栈
2.5 两个对象使用同一个方法
public class Demo02PhoneTwo {
public static void main(String[] args) {
Phone one = new Phone();
System.out.println(one.brand);
System.out.println(one.price);
System.out.println(one.color);
one.brand="苹果";
one.price=8388.5;
one.color="黑色";
System.out.println(one.brand);
System.out.println(one.price);
System.out.println(one.color);
one.call("乔布斯");
one.sendMessage();
System.out.println("===================================");
Phone two = new Phone();
System.out.println(two.brand);
System.out.println(two.price);
System.out.println(two.color);
two.brand="三星";
two.price=5999.0;
two.color="蓝色";
System.out.println(two.brand);
System.out.println(two.price);
System.out.println(two.color);
two.call("欧巴");
two.sendMessage();
}
}
内存图如下：
2.6 两个引用指向同一个对象的地址
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
one.brand="苹果";
one.price=8388.5;
one.color="黑色";
System.out.println(one.brand);//苹果
System.out.println(one.price);//8388.5
System.out.println(one.color);//黑色
one.call("乔布斯");//给乔布斯打电话
one.sendMessage();//群发短信
System.out.println("===================================");
//将one当中保存的对象地址值赋值给two
Phone two = one;
System.out.println(two.brand);//苹果
System.out.println(two.price);//8388.5
System.out.println(two.color);//黑色
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);//蓝色
two.call("欧巴");//给欧巴打电话
two.sendMessage();//群发短信
}
}
内存图如下：
2.7 使用对象类型作为方法的参数
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);//土豪金
}
}
2.8 使用对象类型作为方法的返回值
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 = "玫瑰金";
//谁调用我，我就把one的地址交给谁
return one;
}
}
内存图如下：
3 成员变量与局部变量的区别
/*
成员变量和局部变量
1. 定义的位置不一样
局部变量：定义在方法内部
成员变量：定义在方法外部，直接写在类当中
2.作用范围不一样
局部变量：只有在方法当中可以使用
成员变量：整个类都可以通用
3. 默认值不一样
局部变量：没有默认值，如果要想使用，必须手动进行赋值，否则会报错
成员变量：如果没有赋值就会有默认值，规则和数组一样
4. 内存位置不一样(了解)
局部变量：跟着方法走，位于栈内存
成员变量：位于堆内存
5. 生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
*/
public class Demo01VariableDifference {
public void method(int param) {
//方法的参数param是局部变量,
//按道理说param没有默认值，
System.out.println(param);//那为什么直接使用没有报错呢
//原因：参数在方法被调用的时候必然会赋值
}
}