java 类和对象及类的封装

一. 面向过程 和 面向对象
1.面向过程
面向过程的定义?

一步一步的描述 描述的过程是重点
1
举个例子

简单的来说 如果你要想吃你喜欢的酸辣土豆丝
第一步 准备锅和铲 挑选土豆 葱花 准备佐料
第二步 清洗土豆并削土豆扁丝 切葱花
第三步 锅里放油 葱花 
第四步 将土豆丝放入锅内进行翻炒 
第五步 加入盐之类的佐料 等待
第六步 将炒好的土豆丝盛到盘里
第七步 吃
1
2
3
4
5
6
7
8
大家可以看到 面向过程最重要的就是过程 一步一步的操作

2 面向对象
面向对象的定义?
寻找对象 使用对象 去解决问题 重点在对象

面向对象的好处?

1. 将复杂的问题 简单化 
2. 从事物的执行者 转变为 指挥者
3. 面向对象的思想 是 跟贴近思考问题的思想(懒人思想)
1
2
3
例子:

还是什么好比上面的例子
你想要吃酸辣土豆丝
这个时候你可以找会做酸辣土豆丝的人给你做
1
2
3
3.学习编程是为了什么❓
用所学习的语言解决生活上出现的问题

4.让你来描述一个程序员
1.闷骚
2.帅气
3.近视眼
4.会java语言
5.会c语言 html css+div js

其实
外表简单的来说 就是能看到的 在这里我们对外表的理解就是属性
技能擅长的东西就是行为

 属性 使用名词来描述事物的属性
 行为 使用动词来描述事物的行为
1
2
二. 类 和 对象
通常我们所看到的学生 但是学生那么说 具体到某个人怎么说呢
姓名 某某 年龄多大 学号多少 他会打篮球 会唱歌
其实学生就是一个事物的总称也就是类 具体的姓名 某某 年龄多大 学号多少 加上会唱的行为
就是一个对象

由此引出
类: 一类抽象事物的 集合
对象: 使用类创建出来的 具体的事物 叫做对象

1.面向对象的特征
1.封装
2.继承
3.多态

2.在java中最基本的单位 类
成员变量(实例变量) 相当于属性
书写位置: 在类中,并且方法外
成员方法 相当于行为
目前成员方法跟函数写法一样 只是少一个static
实现代码:

// 狗的类
class Dog{
// 狗的属性
 String name; // 狗的名字
 int age;  //狗的年龄 
// 狗的方法
//关键字 返回值类型 方法名(参数列表){方法体}
 public void introduce(){
  System.out.println("name + "---" + age");
 }
}
1
2
3
4
5
6
7
8
9
10
11
3.面向对象的设计
1 维护类和对象之间的关系
2 不断地操作对象 使用对象 指挥对象去完成一些功能
4.成员变量 和 局部变量 区别 ?

  书写位置不同
  局部变量: 在方法中或者 在方法的声明中
  成员变量: 类中 方法外

  初始化值不同 
  局部变量: 必须给定初始值 才能进行使用
  成员变量: 只要你创建了对象 就会有默认初始值

  内存存在的位置不同
  局部变量: 存储在栈内存中
  成员变量: 存储在堆内存中

  生命周期不同 (对变量的访问时 要考虑一下声明周期 是否可以访问)
  局部变量: 随着方法的入栈而出生 随着方法的出栈而死亡
  成员变量: 随着对象的出生而出生 随着对象的死而死亡
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
实现代码:

  需求 创建一个car类 
  有名字 颜色 轮胎数量 排气量
  可以行使 可以存放物品
1
2
3
4
public static void main(String[] args) {
        // 创建第一个对象car1 (初始化一个对象)
        Car car1 = new Car();
        car1.name = "法拉利"; // 重新赋值
        car1.sayHi();
        //System.out.println(car1.name);
        // 创建第二个对象car2
        Car car2 = new Car();
        car2.name = "兰博基尼";
        car2.color = "蓝色";
        car2.sayHi();
        // 两个对象 三个引用
        Car car3 = car2;
        car3.sayHi();
class Car{
        String name;          // 汽车名字
        String color;         // 汽车颜色
        int numberTires;      // 轮胎数量
        int exhaustVolume;    // 排气量

       public void use(){
            System.out.println("我可以使用");
        }
     public void thing(){
           System.out.println("我可以存放物品");
        }
      }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
那么他们在内存中的表现是什么?

图中方法区 CarDemo.class ,Car.class 和 main函数 字节码都要被加载到内存中的方法区
Car car1 = new Car();
Car car2 = new Car();
Car car1 和 Car car2 都是在栈内存中 new 关键字 在堆内存开辟的两块新内存
并且堆内存里的两个新内存 都有初始值和内存地址 Car类中的属性都是在堆内的两个新内存中
在栈内存的main函数 对象点调用 通过首地址找到堆内存里的new的内存的属性 ,这个时候car1.sayHi在栈内存压栈,然后打印name和color,
因为栈内存有使用完会被立即释放的特点,所以car1.sayHi会被释放然后弹栈,car2也是这个道理

5.匿名对象
匿名对象的含义 : 没有名字的对象
实现代码:

public class personDemo {

     // 赋值name 调用sayHi
     // 相同的语句 可以抽成一个方法
         // 增加代码的复用性
    public static void fun(String name,Person p) {
        p.name = name;
        p.sayHi();
    }
    public static void main(String[] args) {
        fun("李四", new Person());
        // 匿名对象
        // 好处: 节省代码 使用方便
        // 用处: 当你只调用一个方法时使用
        // 如果你要反复调用一个方法 比较浪费内存空间

        new Person();
    }
}
// 首先创建一个类出来Person 
class Person{
// 属性
    String name; // 人的名字
    int age;     // 人的年龄

    // 介绍自己的方法
    public void sayHi() {
        System.out.println(name + "----" + age);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
匿名对象要注意的事项：

我们一般不会给匿名对象赋予属性值，因为永远无法获取到。
两个匿名对象永远都不可能是同一个对象。
匿名对象好处：节省代码 使用方便

用处: 当你只调用一个方法时使用
如果你要反复调用一个方法 比较浪费内存空间

匿名对象的应用场景:

1.如果一个对象需要调用一个方法一次的时候，而调用完这个方法之后，该对象就不再使用了，这时候可以使用匿名对象。

2.可以作为实参调用一个函数。

三. 类的封装
1、什么是封装？

封装就是将属性私有化，提供公有的方法访问私有属性。

做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（get）方法和赋值（set）方法，用于对这些属性的访问。

如：private String name;

// 获取姓名
public String getName(){

        return name;

           }
// 修改名字
public void setName(String name){

              this.name=name;

           }
1
2
3
4
5
6
7
8
9
10
11
12
2、 为什么需要封装？

通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。

由于取值方法和修改值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强。

3、 this关键字是什么意思？

有时一个方法需要引用调用它的对象。为此，java定义了this这个关键字。简单地说，

This是在对象内部指代自身的引用。可以直接引用对象，可以解决实例变量和局部变量之间发生的任何同名的冲突。

4、 如何实现封装，实现封装的具体方法？

（1）、修改属性的可见性来限制对属性的访问。

（2）、为每个属性创建一对修改值方法和取值方法，用于对这些属性的访问。

（3）、在修改值和取值方法中，加入对属性的存取的限制。
————————————————
版权声明：本文为CSDN博主「小东啊」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34936541/article/details/78724658