Day06面向对象1 OOP、类、面向对象、封装

1.面向对象

    OOP：面向对象的简写

  1.面向对象与面向过程

       面向过程干活的是自己，我要怎么干，亲力亲为，关注过程；

       面向对象由执行者变为指挥者找谁干，干什么，关注结果；

       面向过程和对象都是一种编程思想，java是一门面向对象的语言，

       而对象贯穿始终，想干活，先创建对象。

  2.面向对象的三大特征
       1）.封装：把相关的数据封装成一个“类”组件
       2）.继承
       3）.多态

 默认抽象也是面向对象的特征
  3.类和对象
       1）类
          1.java语言最基本单位就是类，类似于类型
          2.类是一类事物的抽象，事物的共同特征
          3.类可以理解为模板或设计图纸（汽车图纸）
            一个源文件中，public只能修饰一个类（class），同一个包下，不能创建同名的类
      2）对象
         照着一个类做出很多对象，每个对象都要对应的序列号，对象是类的实现
         1.对象的状态用来描述对象的基本特征
         2.对象的行为用来描述对象的功能
         3.对象的标识是指对象在内存中都有一个唯一的地址值，用来和其他对象区分开来。
         4.类是一类事物的抽象，对象是具体的实现（实际造出来的汽车）
   4.类和对象的关系
        计算机语言来怎么描述现实世界中的事物的? 属性（特征）+ 行为（功能）
        那怎么通过java语言来描述呢?
        我们可以通过类来描述一类事物,用成员变量描述事物的属性,用方法描述事物的行为

  练习：创建手机这个类的案例：  

package cn.tedu.oop;

/**面向对象过程
 * //分析手机这类事物--用类描述
 * //特征：品牌、价格、颜色、尺寸
 * //行为：打电话、打微信、看直播
 */
/**一个java文件中可创建多个class，但被public修饰的class只能有一个
 * 而且这个公共类必须与文件名一致，也就是公共类的名字就是文件名
 */
public class TestCreateClass {
    /**4.在公共类中创建程序入口函数main()方法*/
    public static void main(String[] args) {
        /**5.创建手机类的对象p*/
     Phone p = new Phone(); //p保存的是变量的地址值
        /**6.通过“.”调用对象的具体功能*/
        p.call();
        p.learn();
        p.message();
        /**7.打印查看对象的具体值*/
        System.out.println(p.brand);
        System.out.println(p.color);
        System.out.println(p.price);
        System.out.println(p.size);
        /**8.创建手机类的对象2*/
         Phone p2 = new Phone();
         p2.message();
         /**9.修改p2对象的相关属性值*/
         p2.brand = "HUAWEI";
         p2.color = "赤橙红绿的白";
         p2.price = 8888.88 ;
         p2.size = 6.7;
        System.out.println(p2.brand);
        System.out.println(p2.color);
        System.out.println(p2.price);
        System.out.println(p2.size);


    }
}
/**1.通过class关键字描述手机这一类事物*/
class Phone{
    /**2.通过成员变量来描述手机这类事物的特征
     * 成员变量：类里方法外，无需手动初始化赋值*/
    //特征：品牌、价格、颜色、尺寸
    String brand;//品牌
    String color;//颜色
    double price;//价格
    double size;//尺寸
    /**3.通过方法来描述手机这类事物的功能
     * 格式：修饰符  返回值类型 方法名(参数列表){方法体}*/
    //行为：打电话、打微信、看直播
    public void call(){
        System.out.println("假装正在打电话~");
    }
    public void message(){
        System.out.println("假装正在发短信~");
    }
    public void learn(){
        System.out.println("假装正在看直播~");
    }

}

5.具体对象创建的流程：

1）.在main（）方法外，通过class关键字创建描述手机这一类事物
2）.通过成员变量来描述手机这类事物的特征
3）.通过方法来描述手机这类事物的功能
4）.在公共类中创建程序入口函数main()方法
5）.创建手机类的对象p
6）.通过“.”调用对象的具体功能
7）.打印查看对象的具体值
6.编程思路：
6.1 抽象相关信息，封装成一个类，类相当于设计图纸
1）特征--属性--用成员变量来描述；
2）行为（功能）--方法--用方法来描述
6.2 创建对象，通过new关键字来创建对象Phone p= new Phone();
TIPS（小贴士）：p是一个引用类型变量，它保存着的是对象的地址值
6.3 通过创建好的对象来调用功能，查看属性
TIPS:同一个类创建多个对象之间没有相互关系，并不相互影响
7.1 对象在内存中的存储
队列：先进先出FIFO(first in first out）
栈:后进先出LIFO（last in first out)先进后出
7.2 创建对象时，内存究竟经历了什么？
1）.在栈内存中开辟一块空间，存放引用类型变量p，并把p压入栈底
2）.在堆内存中开辟了一块空间，存放Phone对象
3）.完成对象的初始化，并赋予默认值
4）.给初始化完毕的对象赋予唯一的地址值
5）.把地址值交给引用类型变量p来保存
8.使用3w1h原则描述面向对象OOP
1）what--是什么：面向对象是一种编程思想
2）why--为什么使用面向对象：相较于之前的面向过程而言，面向过程强调的是过程，凡事亲力亲为，而面向对象强调的是结果，我们由之前每件事物的具体执行者转变为指挥者，要做事情，先创建对象出来，通过对象完成具体业务，提高效率
3）when--何时何处使用它：java是一门面向对象的语言，万物皆对象，正是因为对象无处不在，所以容易被忽略，与其他技术点来说，面向对象的思想无处不在，只要想干活，必须先创建对象
4）how--如何使用它，使用时的注意事项:
9.编程顺序：
1）总结归纳一类事物的特点与行为，通过抽象，封装成一个“类”组件；类中包含：属性--成员变量（赋值） 行为---方法（调用）
2）通过new关键字，创建指定类的对象
3）有了对象，就可以通过“对象."来使用类中的所有资源
10.注意事项：
1）.一个Java文件中只能有一个公共类，且此类与文件名同名
2）.自定义抽象形成的类与公共类是并列关系
3.）在同包下，不能创建两个同名的class
4）.根据同一个类模板创建出来的多个对象间不会互相影响

2.封装private（关键字）

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

2.总结归纳把一些属性和行为进行抽象，封装成一个“类”组件，提高重用性，比如Phone类
3.对类中的资源用private关键字进行修饰封装属性和方法，阻止外界直接访问资源，提高程序的安全性,
  1）属性的封装：
属性前加private，一旦封装属性，被private修饰的资源只能在本类中使用；
我们需要提供对应的属性设置值和访问值方法：getxxx（）--获取属性值；setxxx（）--设置属性值；
我们可以提高封装阻止外界直接访问资源，想要访问，必须按照我的方式来封装方法
  2）方法的封装：
       用private进行修饰的方法，被private修饰的资源外部无法直接访问
       可以在本类公共的方法中调用私有方法，如果想执行此私有方法的功能，调用公共方法即可
3.封装的步骤：
1）.创建手机的类class XXXX{ }
2）.成员变量来描述手机的属性特征String brand;
3）.方法来描述手机的行为功能public void call(){}
4）.在公共类中创建程序入口函数main（）方法，并创建手机类的对象：Phone p = new       Phone();
5）.通过“.”来调用手机类的具体属性和功能 p.call();System.out.println(p.brand);
6.1）对属性的封装,在属性前加private,提供对应的封装属性设置值和获取访问值两个方法//封装下方空白行，鼠标右键Generater--》Getter and Setter--》按住shift键单击最后一个红色锁标全选，ok即可
6.2）把第5步的调用注释掉，调用get和set方法设置对应属性的值//先set后get,缺一个方法都没有输出值：p.setBrand("HUAWEI");System.out.println(p.getBrand());set修改属性值，get获取查看属性值
7.1）对方法的封装，public 换成 private，// 只留一个public，把封装的方法名+参数列表（）复制到唯一的public方法的内
7.2）调用普通方法public修饰的那个方法提取封装后的方法

练习：封装学生案例

package cn.tedu.oop;
/**本类测试学生类的封装*/
public class TestPrivate {
    /**4.在公共类中创建程序入口函数main（）方法
     * 创建学生类的对象*/
    public static void main(String[] args) {
        Student s =new Student();
        /**5.通过创建好的对象，查看对象的属性值，调用方法*/
        //s.study();//调用学习功能
        //s.eat();//调用干饭功能
        System.out.println(s.name);//查看s对象的name姓名属性值
        System.out.println(s.sNum);//查看s对象sNum学号属性值
        //System.out.println(s.subject);//查看s对象subject科目属性值
        //'subject' has private access in 'cn.tedu.oop.Student'通过路径访问权限
        s.setSubject("侦探");
        System.out.println(s.getSubject());
        s.study();

    }

}
/**1.通过class关键字封装一个学生类*/
class Student{
    /**2.描述学生这一类事物的属性--通过成员变量*/
    String name = "柯南";//姓名
    int sNum =2105;//学号
   private String subject = "侦探";//科目//封装：属性前加private，外界main（）方法无法用
    /**空白处右键-->Generate-->Geter and seter-->红锁图标ok*/
    public String getSubject() {//get方法是获取值
        return subject;
    }

    public void setSubject(String subject) {//set方法是设置值
        this.subject = subject;//this表示当前类
    }

    /**3.描述学生这一类事物的行为--通过方法*/
    public void study(){
        System.out.println("我们在学习java。");
        eat();//私有方法调用，把私有方法复制到公共方法里
    }
    private void eat(){//public也可以封装，外界也无法用
        System.out.println("韭菜加鸡蛋，越吃越能干！");
    }

}

面试题TIPS:1.如何封装?
                      我们可以使用private关键字来封装成员变量与方法
                    2.如何访问私有资源?
                       1）.关于成员变量:
                            setXxx – 对外提供公共的设置值方式
                            getXxx – 对外提供公共的获取值方式
                      2）.关于成员方法:
                            把私有方法放在公共方法里供外界调用即可

3.拓展：OOP综合练习

创建包：cn.tedu.oop

创建类:TestCar

package cn.tedu.oop;
/**本类用于面向对象的巩固练习*/
public class TestCar {
    //3.创建程序入口函数main（）方法
    //创建汽车类对象c
    public static void main(String[] args) {
        Car c =new Car();
        //4.通过汽车类
//        c.color = "暗夜紫";
//        c.brand = "BWM";
//        c.length = 0.2;
//        c.price = 200;
//        //5.查看设置好的属性值
//        System.out.println(c.brand);
//        System.out.println(c.color);
//        System.out.println(c.length);
//        System.out.println(c.price);
        //6.通过c对象调用汽车类的方法
        //c.start();
        //c.stop();
        //7.3调用提供的set与get方法，设置并获取对应属性的值
        c.setBrand("特斯拉");
        c.setColor("black");
        c.setPrice(200.02);
        c.setLength(3);
        System.out.println(c.getBrand());
        System.out.println(c.getColor());
        System.out.println(c.getPrice());
        System.out.println(c.getLength());
        //8.3调用公共类来实现私有方法功能的使用
        c.start();

    }
}
//1.抽象汽车这一类事物的属性和行为，封装成一个类组件
class Car{
    //2.属性--用成员变量来描述
    //7.1封装所有属性值--使用private修饰
    private String color;
    private String brand;
    private double price;
    private double length;
    //7.2生成所有属性的set和get方法
/**右键空白处-->Generate-->Getter and setter-->按住shift单击最后一个红锁图案可全选所有属性，ok即可生成get、set方法*/
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    //2.行为（功能）--用方法来描述
    //8.2可以在本类公共的方法里，调用私有方法
    public void start(){
        System.out.println("汽车开动了");
        stop();//调用是有方法stop
    }
    //8.1封装方法，通过Private
    private void stop(){
        System.out.println("汽车停止了");
    }
}

4访问控制符

作用：用来控制一个类，或者类中的成员的访问范围。

TIPS:default是表示不写修饰符,默认,如果写default单词来修饰会报错

5.匿名对象

没有名字的对象，是对象的简化表示形式。
使用场景：
当被调用的对象只调用一次时（多次会创建多个对象浪费内存）
Demo d = new Demo();
d.sleep();
d.game();
//这个d就是对象的名字。
也可以写成：
new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法