Java100天编程指南---第12天：面向对象（基础）
目录
一、前言
二、类和对象
1.概念
2.定义
3.构造
4.总结
三、内存图
1.编码实现
2.输出结果
3.原理讲解
四、构造器
1.概念
2.样例
五、this关键字
1.概念
2.样例
六、封装
1.概述
2.步骤
3.总结
七、标准类
1.问题分析
2.编码实现
3.输出结果
附录
一、前言
- 学习概述：从本章开始，正式进入到java面向对象的学习，主要学习设计类和对象、内存图、构造器、this关键字、封装、标准类
- 学习目标：两个重点获取已有对象、自己设计对象使用
二、类和对象
1.概念
- 前11天我们学习了Java的基础语法，今天我们正式进入java的面向对象编程。
- 对象：面向对象不是一门技术，大多为一种思想，把现实生活中的小米手机、红旗汽车、歼20....这些现实中具体事务，抽象成一个个对象。
- 对象的属性：我们上面把手机看作一个对象，小米手机的品牌、价格、外观为对象的属性
- 对象的行为：对象能够执行的操作，比如小米手机可以打游戏、发短信、浏览CSDN等操作
- 面向对象：平常我们买手机所筛选的分类、价格、外观等条件的过程，其实就是面向对象
- 类：类是具有共同属性和行为事物的抽象，比如小米、华为笼统成手机，并没有表明品牌，是java程序的基本组成单位
- 使用原因：生活中我们解决问题也是按照对象化的方式解决的，java这种编码更加符合我们的思维习惯
2.定义
- 类由属性和行为构成，这部分在代码分别使用成员变量、成员方法表述
public class 类名 {
1、成员变量（属性,一般是名词)
2、成员方法（行为,一般是动词）
3、构造器
4、代码块
5、内部类
}
构造了一个类之后，如何得到类的对象？如何使用类的变量和方法？
类名 对象名 = new 类名();
访问变量: 对象名.成员变量
访问方法: 对象名.方法名(…)3.构造
- 下面定义一个汽车类，并抽象出名称为Maserati、Benz两个对象 c1 c2
Car类
public class Car {
//定义变量
String name;
double price;
//定义方法
public void start()
{
System.out.println(name+"启动了！");
}
public void run()
{
System.out.println(price+"的"+name+"开跑了！");
}
}
对象
Car c1=new Car();
Car c2=new Car();4.总结
- 关系：类是对象的抽象，对象是类的实体
- 特点：一个java文件中可以定义多个class，但只能有一个为public修饰（为代码文件名）
- 命名规则：类名首字母建议大写，尽量用有意义的英文名称，驼峰命名规则
三、内存图
下面，上面的Car类生产了c1、c2对象，下面调用一下类中的方法、变量
1.编码实现
public class Demo {
public static void main(String[] args)
{
//生成对象 c1
Car c1=new Car();
c1.name="Maserati";//设置变量
c1.price=9.99;
System.out.println(c1.name);//调用变量
System.out.println(c1.price);
c1.start();//调用方法
c1.run();
System.out.println("------------");
//生成对象 c2
Car c2=new Car();
c2.name="Benz";
c2.price=9.99;
System.out.println(c2.name);
System.out.println(c2.price);
c2.start();
c2.run();
}
}2.输出结果
Maserati
9.99
Maserati启动了！
9.99的Maserati开跑了！
------------
Benz
9.99
Benz启动了！
9.99的Benz开跑了！3.原理讲解
- 栈内存一般存储局部变量、方法，堆内存存储成员变量、类、数组对象
- 我们new出来的c1、c2为对象在堆内存的地址，调用类中的变量、方法。java中的自动垃圾回收器会定期清理没有变量引用的对象
四、构造器
1.概念
- 作用：初始化类的对象，并返回地址。分为无参构造器（默认存在）、有参构造器
2.样例
//无参构造器
public Car(){}
//带参构造器
public Car(String n,double p)
{
name=n;
price=p;
}
- 但一旦定义有参构造器，就必须写一个无参的构造了
五、this关键字
1.概念
2.样例
- 使用this关键字之后，指向更加明确，命名也更加规范
六、封装
1.概述
- 面向对象的三大特征：封装、继承、多态，今天我们来学习封装
- 作用：private（私有关键字）隐藏实现细节，同时暴露出合适的访问方式
2.步骤
- 对成员变量使用private修饰隐藏（只能在本类中访问），构造public getter setter让外部访问
- Eclipse点击Source->Genearte Getters Setters可以自动创建，构造方法也一样
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}3.总结
- 封装加强了代码的安全性
七、标准类
- 满足标准类，需要满足成员变量使用 private 修饰、每一个成员变量对应的get set方法、提供一个无参构造器
- 下面实现一个标准学生类
1.问题分析
- 我们定义三个private修饰的变量id、name、age，生成对应的get set方法
- 构造带参、无参构造方法、输出变量方法
- 测试类，传入数据、输出信息
2.编码实现
Student类
public class Student {
//定义变量
private int id;
private String name;
private int age;
//无参构造方法
public Student() {}
//带参构造方法
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
//封装所有private修饰的变量
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
//输出当前成员信息
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
测试类
public class Demo {
public static void main(String[] args)
{
//带参构造方法生成对象
Student s=new Student(10010, "张三", 15);
//修改年龄
s.setAge(25);
System.out.println(s.getAge());//得到修改过后的年龄
System.out.println(s.toString());//调用方法
System.out.println("------------------");
//无参构造方法，传入信息
Student s1=new Student();
s1.setId(10011);
s1.setName("李四");
s1.setAge(26);
System.out.println(s1.toString());//调用方法
}
}3.输出结果
25
Student [id=10010, name=张三, age=25]
------------------
Student [id=10011, name=李四, age=26]
- 构造对象应该优先使用带参构造方法
附录
| 区别 | 成员变量 | 局部变量 |
| 类中位置 | 类中，方法外 | 方法中 |
| 初始化值 | 存在默认初始化值 | 无初始化，使用需要赋值 |
| 内存位置 | 堆内存 | 栈内存 |
| 生命周期 |
随着对象的创建而存在，随着对象的消
失而消失
|
随着方法的调用而存在，随着方法的运行结束而消失
|
| 作用域 | 看修饰符而定 | 方法内部 |