面向对象、类和对象、封装---------私有private、this关键字

1、面向对象和面向过程

面向对象是让谁干什么

面向过程是按什么顺序来干（干活过程都有参与）

所以在工作中，面向对象更好。

例如：

以打扫办公室为例：面向过程就是将扫地、拖地、擦玻璃、擦门窗这几件事情排好（做好）顺序，先干啥再干啥，需要按照顺序一件一件的参与干活‘

面向对象就是打扫卫生时，小李拖地，小杨擦玻璃，小张擦门窗，小孙擦门窗，每个人干不同的活，最后将办公室打扫干净；

再比如：买电脑：面向过程就是查找想要的型号，询价零件、购买、组装、搬回家。在整个过程中我们参与了每一个细节，并且会感觉相当累。

面向对象就是找个专门懂得人帮忙查看配置、组装等，不需要亲历亲为具体怎么做，只要告诉这个人我们想要的具体需求即可。

 面向过程思维方式中更多的体现的是执行者（自己做事情），面向对象中更多的体现是指挥者（指挥对象做事情）。

2、类和对象

 （1）类在需求中的使用--------------类的定义方式及在代码中的实现

已将大象关进冰箱这个需求来举例：

需求：把大象装冰箱里

对象：大象、冰箱

分三步：

　　第一步打开冰箱门

　　第二部将大象装进去

　　第三步关闭冰箱门

冰箱对象具备如下功能：

　　冰箱打开

　　冰箱存储

　　冰箱关闭

------------1、创建冰箱的对象

　　冰箱 bx = new 冰箱();  

-----------2、调用冰箱的功能

　　对象.功能()；

　　bx.打开();

　　bx.存储(new 大象());

　　bx.关闭();

代码就是：

public class Daxiang {

}//先定义一个Daxiang类

public class Bingxiang {//再定义一个 Bingxiang，类名大写

public void open(){//方法

 System.out.println("冰箱打开了");
 }
 public void save(Daxiang dx){
 System.out.println("将大象装进来");
 }
 public void close(){ 
　　System.out.println("冰箱关闭了"); 
　　}
 }

public class Test {//定义一个测试的类
    public static void main(String[] args) {
        Bingxiang bx = new Bingxiang();//创建对象，new 一个对象
        Daxiang dx = new Daxiang();
        bx.open();//调用方法
        bx.save(dx);
        bx.close();
    }

}

l定义类的格式

public class 类名 {

　　//可编写0至n个属性

   　　 数据类型 变量名1；

   　　 数据类型 变量名2；

　　//可编写0至n个方法

　　修饰符 返回值类型 方法名(参数){

　　执行语句;

　　}

　　}

再以汽车为例：

汽车（事物）的特点（属性）：

汽车的颜色。

轮胎个数。

事物的(功能)：

运行。

-----------即：

--------------小汽车 {

------------------------------颜色；

------------------------------轮胎个数；

---------------------运行() { }

---------------------}

public class Car {
    String color;//颜色
    int number;--------------成员变量
    public void run() {//定义一个方法，
        System.out.println(color + ":" + number);
    }
}

类的真正意义就是在描述事物。属性和功能统称为事物中的成员。

事物的成员分为两种：成员属性和成员功能。

成员属性在代码中的体现就是成员变量

成员功能在代码中的体现就是成员方法

public class CarDemo {
    public static void main(String[] args) { 
        /*
         *  测试：Car类中的run方法。
         */
        // 1,创建Car的对象。给对象起个名字。
        Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。
        // 2,通过已有的对象调用该对象的功能。格式：对象.对象成员;
        // 3,可以该对象的属性赋值。
        c.color = "red";
        c.number = 4;
        c.run();
    }
}

（2）类和对象的区别

----------------类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

例如：制作玩具的模型就是类，对象则是一个个玩具

（3）局部变量和成员变量的区别

第一个：定义位置不同：成员变量是在类中，局部变量是在方法中或者{}语句里面

第二个：在内存中的位置不同：局部变量在栈中的方法里，成员变量在堆中的类中

第三个：生命周期不同：局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失；成员变量则是随着类在存储在堆中，对象消失，成员变量才消失

第四个：初始化不同：成员变量随着类进入堆中，会被默认赋值为0或者null等，局部变量没有初始化值，手动赋值才行

 3、封装

1、封装概述

封装：在方法中，就是将具体的功能封装到方法中。在对象中就是将方法封装到类中。

面向对象的三个基本特征：封装、继承、多态

①封装的表现：

-------------方法就是一个最基本的封装体

-------------类其实也是一个封装体

②封装的好处：

---------------提高了代码的复用性

--------------隐藏了实现细节，向外部提供访问的方式，便于调用者使用，这是封装的核心，也可以说是封装的概念。

---------------提高了安全性

③封装的举例说明：就拿台式机的主机来说，主机有cpu、硬盘、主板等构成，如果主机外部不加一个外壳，那么内部的组成部分就裸露在外部，会变得很不安全

外壳就可以看成是一个封装，其上的USB等接口可以看成是其提供的让外部访问的方式。

(2)私有private

类中的属性的行为可以任意访问和使用，因此要使用关键字也是一个修饰符（私有private）。

例如：

package demo01;
//privat:私有，可以修饰类，被修饰的成员只能在本类中访问
public class Person {
 private int age;---------------私有化
private String name;
//对外提供公共访问方式
public void setage(int a){
    if(a>=0&&a<130){
        age=a;
    }else {
    age=0;
    }
}
public int getage(){//-----------------------鼠标右击------------Source------Generate Getters and Setter
    return age;
}
public void setname(String n){
    name=n;
}
public String getname(){
    return name;
}
public void speak(){
    System.out.println("我叫"+name+",今年"+age+"岁");
}
} 

package demo01;

public class Text {

    public static void main(String[] args) {
        Person p=new Person();
        p.setname("佩奇");//-------------通过方法赋值。访问私有的对象属性
        p.setage(18);
        p.speak();
        System.out.println(p.getage());
        System.out.println(p.getname());
    }

}

l 总结：

类中不需要对外提供的内容都私有化，包括属性和方法。

以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。

l 注意：私有仅仅是封装的体现形式而已。

（3）this关键字

在方法中出现局部变量和成员变量同名时，可以添加this关键字来进行区分，可以在成员变量名前面加上this.来区别成员变量和局部变量

Public class Person {
    private int age;
    private String name;
    
    public void speak() {
        this.name = "小强";
        this.age = 18;
        System.out.println("name=" + this.name + ",age=" + this.age);
    }
}

Public class PersonDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.speak();
    }
}

对象的内存解释

程序执行流程说明：

1、首先在数据和方法共享区读取.class文件，main方法。

2、 先执行main方法（压栈），执行其中的 Person p = new Person()；

3、看到new一个对象则 在堆内存中开辟空间，并为其分配内存地址0x000，紧接着成员变量默认初始化(age = 0)；将内存地址0x000赋值给栈内中的Person p 变量

4、继续执行p.setAge(30)语句，这时会调用setAge(int age)方法，将30赋值为setAge方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；

5、setAge()方法执行完毕后（弹栈），回到main()方法，执行输出语句System.out.println()，控制台打印p对象中的age年龄值。

4、继承

（1）继承的概述：

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。

例如：

类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。

格式：

public   class 子类 extends 父类 {  }

集成的举例：

package damo03;

public class Fu {
    int a=6;
}

package damo03;
//在继承中，成员变量的特点：
//如果父类成员变量和子类成员变量同名，那么调用的是子类的成员变量
//在继承中，子类只能继承父类可继承的成员，私有化的成员，可以继承，但是没法使用和操作，相当于没继承
public class ZI extends Fu{//------------------继承父类
    int a=2;
    public void speak(){
        int a=3;
        System.out.println(this.a);
        System.out.println(super.a);
    }
}

package damo03;

public class Text1 {
public static void main(String[] args) {
    ZI bb=new ZI();
    bb.speak();
}
}

Zi类通过extends关键字继承了Fu类。

子类虽然没有定义int a=1;的属性和work()方法，但是却能访问这这个成员。这就说明，子类在继承父类的时候，会自动拥有父类的成员。

 继承的好处与注意事项：

好处：

1、提高了代码的复用性，

2、继承的出现让类与类之间产生了关系，提供了多态的前提。

 注意事项：

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类 

class A{}

     class B{}

     class C extends A,B{}  // C类不可以同时继承A类和B类

2、多个类可以继承一个父类

 class A{}

     class B extends A{}

     class C extends A{}   // 类B和类C都可以继承类A

（2）子父类中成员变量的特点

----------------Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类是不能直接访问的。当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

在子类中，访问父类中的成员变量格式：

super.父类中的成员变量

class Fu
{
    //Fu中的成员变量。
    int num = 5;
}

class Zi extends Fu
{
    //Zi中的成员变量
    int num = 6;
    void show()
    {
        //子父类中出现了同名的成员变量时
        //在子类中需要访问父类中非私有成员变量时，需要使用super关键字
        //访问父类中的num
        System.out.println("Fu num="+super.num); //访问子类中的num2
        System.out.println("Zi num2="+this.num);
    }
}

class Demo5 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi(); //创建子类对象
        z.show(); //调用子类中的show方法
    }
}

 （3）子类继承父类的的方法特点：直接继承和重写

当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

class Fu{-----------------------------------------------------------------------------父类
    public void show(){---------------------------------------------------------------show方法
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu{-------------------------------------------------------------------子类继承父类的方法
    public void show2(){---------------------------------------------------------------子类的show2方法
        System.out.println("Zi类中的show2方法执行");
    }
}
public  class Test{
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); //-------------------------------------------------------------------子类中没有show方法，但是可以找到父类方法去执行
        z.show2();----------------------------------------------------------------------父类中没有show方法，就执行的父类中的方法
    }
}

 成员方法特殊情况——覆盖

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖。方法重写

class Zi extends Fu
{
    //子类复写了父类的show方法
    public void show()
    {
        System.out.println("Zi show");
    }
}

l 方法重写（覆盖）的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

例如：增加功能

比如手机，当描述一个手机时，它具有发短信，打电话，显示来电号码功能，后期由于手机需要在来电显示功能中增加显示姓名和头像，这时

可以重新定义一个类描述智能手机，并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能，在其中增加显示姓名和头像功能。

class Phone{--------------------------------------------属性
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");
    }
}

//智能手机类
class NewPhone extends Phone{-----------------------继承父类属性
    
    //覆盖父类的来电显示号码功能，并增加自己的显示姓名和图片功能
    public void showNum(){
        //调用父类已经存在的功能使用super
        super.showNum();
        //增加自己特有显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}

public class Test {
    public static void main(String[] args) {
        new NewPhone().showNum();
    }
}

注意：

l 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

l 写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。

总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写。