面向对象概念

面向对象与面向过程都是一种思想。
面向过程强调的是过程，强调凡事亲历亲为。
面向对象强调的是结果，不关心过程，只需要指挥不需要执行。
JAVA是一种面向对象的语言。

面向对象的三大特征

  1. 封装：把相关的数据封装为一个“类”组件。
  2. 继承：继承是子类自动继承父类的属性与方法，是类之间的一种关系。

  3. 多态：增强软件的灵活性与重用性。

    封装

  4. 将一类事物的功能与特征封装为一个“类”组件

  5. 限制属性或方法的使用

    概述

    封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
    好处:

  6. 提高安全性

  7. 提高重用性

    private关键字

    属性的封装

  8. 使用private修饰属性

  9. 提供对应的get与set 使用方法：
  10. 给封装的属性设置值：setXxx()—设置值时需要传参

  11. 获取封装的属性值：getXxx()

    方法的封装

  12. 用private修饰方法

  13. 可以在同类中的公共方法里调用这个私有方法
  14. 这样就可以在其他类中，创建对象，调用公共方法

    示例

    属性封装

    ```java package cn.tedu.oop;

/* 用于测试封装 */

public class TestPrivate { public static void main(String[] args) { Student s = new Student(); s.setId( 2019071033); s.setName(“埼玉”); //s.subject = “Java”; s.setSubject(“Java”); System.out.println(s.getName() + “的学号是:” + s.getId() + “,最近在学” + s.getSubject()); s.study(); s.play(); } }

class Student{

  1. //特征--成员变量
  2. private int id;
  3. private String name;
  5. /*
  6. 关于方法的第四个要素：返回值类型
  7. 如果一个方法需要返回结果，那么通过return关键字返回
  8. 注意：返回值类型String必须与返回值subject的类型保持一致
  9.  */
  10. public int getId() {
  11.     return id;
  12. }
  14. public void setId(int id) {
  15.     this.id = id;
  16. }
  18. public String getName() {
  19.     return name;
  20. }
  22. public void setName(String name) {
  23.     this.name = name;
  24. }
  26. public String getSubject() {
  27.     return subject;
  28. }
  30. public void setSubject(String subject) {
  31.     this.subject = subject;
  32. }
  34. /*
  35. 属性封装--直接在属性前加private即可
  36. private 私有的
  37. private修饰的是私有资源
  38. 私有资源只能在本类中访问，外部无法访问。
  39.  */
  40. private String subject;
  42. //功能--方法
  43. public void study(){
  44.     System.out.println("头悬梁锥刺骨的学习时间");
  45. }
  47. public void play(){
  48.     System.out.println("愉快的玩耍时间");
  49. }

}

  1. <a name="hSpgf"></a>
  2. #### 方法封装
  3. ```java
  4. package cn.tedu.oop;
  6. public class TestMethodPrivate {
  7.     public static void main(String[] args) {
  8.         Dog d = new Dog();//4.创建对象
  9.         d.eat();//5.调用两个方法
  10.         //d.play();//封装后私有方法无法直接调用
  11.     }
  12. }
  14. class Dog{//1.创建类
  15.     public void eat(){//2.创建公共方法
  16.         System.out.println("别看我是一只汪");
  17.         play();//在公共的本类中的方法中调用被封装的方法
  18.     }
  20.     private void play(){//3.创建私有方法
  21.         System.out.println("狗拿耗子多管闲事");
  22.     }
  23. }

类与对象

类是抽象的，是设计图纸。
对象是具体的，是根据设计图纸设计出来的工具。

类

  1. Java语言最基本单位就是类，类似于类型。
  2. 类是一类事物的抽象。

  3. 可以理解为模板或者设计图纸。

    对象

    每个对象具有三个特点：对象的状态，对象的行为和对象的标识。

  4. 对象的状态用来描述对象的基本特征。

  5. 对象的行为用来描述对象的功能。
  6. 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
  7. 类是一类事物的抽象，对象是具体的实现。

    示例

    ```java package cn.tedu.oop;

/**

  • 练习面向对象入门案例
  • 需求：设计手机这类事物
  • 特性：品牌 价格 尺寸 颜色
  • 功能：打电话 发短信 看直播 */

public class TestCreateClass { public static void main(String[] args) { //通过new关键字创建对象 Phone p = new Phone(); Phone p2 = new Phone(); //使用对象.方法名调用功能 p.call(); p.message(); p.video(); p2.call(); p2.video(); p2.message(); //查看对象的属性值 System.out.println(p.brand); System.out.println(p.price); System.out.println(p.color); System.out.println(p.size); //修改成员变量的值 p2.brand = “华为”; p2.color = “素皮”; p2.price = 5999.9; p2.size = 6.54; System.out.println(p2.brand); System.out.println(p2.price); System.out.println(p2.color); System.out.println(p2.size); } }

/ 在一个Java文件中可以创建多个class,但是只能有一个由public修饰的class,并且这个class的名字就是文件名 /

//通过class关键字创建一个手机类用于描述手机这一类事物 class Phone{

  1. //特征--类的成员变量来描述--位置为类里方法外
  2. String brand;//品牌
  3. double price;//价格
  4. double size;//尺寸
  5. String color;//颜色
  7. //功能--类的方法来描述--修饰符 返回值类型--方法名--(参数列表){方法体}
  8. public void call(){
  9.     System.out.println("正在打电话···");
  10. }
  12. public void message(){
  13.     System.out.println("正在发短信···");
  14. }
  16. public void video(){
  17.     System.out.println("正在看直播···");
  18. }

} ```

对象在内存中的存储

  1. 一般来讲局部变量存在栈中，方法执行完毕内存就被释放对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
  2. 每个堆内存的元素都有地址值

  3. 对象中的属性都是有默认值的

    栈和队列

    TIPS: 栈与队列指的是一种数据的结构。
    栈：先进后出（FILO – First In Last Out）
    队列：先进先出（FIFO – First In First Out）

    创建对象时内存分析

  4. 在栈内存中开辟了一块空间，存放引用类型变量p，并把p压入栈底

  5. 在堆内存中开辟一块空间，存放Phone对象
  6. 完成对象的初始化，并赋予默认值
  7. 给初始化完毕的对象赋予唯一的地址值
  8. 把地址值交给引用类型变量p来保存

image.png
p2.brand = “HUAWEI”;就是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到对应的Phone对象,并对其对应的属性值进行修改
p2.eat();
也是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到对应Phone对象,执行Phone对象的eat()方法

普通对象

Cat c= new Cat();——创建了普通对象

  1. 在栈内存中开辟一块空间,存放引用类型的变量c并把c压入栈底
  2. 在堆内存中开辟一块空间,用于存放Cat类的对象
  3. 完成对象的初始化,并根据属性类型赋予对应的默认值
  4. 给初始化完毕后的对象生成一个唯一的地址值
  5. 将对象唯一的地址值交给引用类型变量c来保存

  6. 后续可以根据变量c中保存的地址值找到对应的对象,进行相关调用

    匿名对象

    new Cat();—创建了匿名对象

  7. 在堆内存中开辟一块空间,用于存放Cat类的对象

  8. 完成对象的初始化,并根据属性类型赋予对应的默认值
  9. 给初始化完毕后的对象生成一个唯一的地址值
  10. 匿名对象没有名字,只能使用一次,所以调用: new Cat0.play0
  11. 调用完毕,匿名对象就失去作用了,只适合只使用一次的场景