面向对象、类和对象、封装---------私有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 写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。
总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写。
