Java基础---面向对象（面向对象，类，对象，匿名对象，封装，构造函数，构造代码块，this，static，main，帮助文档，静态代码块，单例）

一. 面向对象概念：

面向对象其实是一种思考的思想，早期思想是面向过程。
面向过程注重的是过程，过程所涉及的行为，也就是功能。

【实例】：面向过程： 1. 把冰箱打开 2. 把大象放入 3. 冰箱关起来
     面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

【总结】： 所属在冰箱中，先看到冰箱，有了冰箱就有了这些功能，把这些功能封装在冰箱中。
      先找到这些功能有哪些特性，所属于什么事物，找到事物，把功能全封装进去。

【面向对象概念】

1. 面向对象是思考问题的一种思考方式，是一种思想。
2. 面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

【面向对象设计】

面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据（私有）的方法！
（被动的一方是数据的拥有者，主动的一方是执行者）

【实例 1】：人在黑板上画园：
     => 对象：person, blackboard, circle

draw() //画圆
{
    (x, y)  //圆心
    radius  //半径
}

/*圆心和半径是circle内部的数据，画圆的方法要操作圆心和半径
  所以画圆的方法是圆提供的。
*/

【实例 2】：列车司机紧急刹车
     => 对象：司机, 列车
     => 刹车的动作：列车身上的方法


【实例 3】：售票员统计收获小票的金额
     => 对象：售票员, 小票
     => 统计收获小票的金额的方法：是小票身上的方法。
      因为商品的价格是在小票内部的数据，售票员只是调用小票的getTotalMoney( )


【实例 4】：你把门关上了：[ 名称提炼法 ]
     => 对象：门, 人
     => 关门的方法：是门身上的方法，人只是调用门的closeDoor( )

closeDoor() //关门
{
    //旋转; 装到门框; 伸出锁舌; 插到锁孔;
}

【实例 5】：路上有很多汽车，路上还随时可以增加，减少汽车：
     => 对象：路, 汽车
     => 增加，减少汽车的方法：是路身上的方法，不是汽车自己冲过去的。


【实例 6】：球从一根绳子的一端移动到了另一端：
     => 对象：球, 绳子
     => 绳子：为球的移动指引了方向 nextPoint( )
      球：move( )

class Rope
{
    private Point start;
    private Point end;
    public Rope(Point start, Point end)
    {
        this.start = start;
        this.end = end;
    }

    public Point nextPoint(Point currentPoint)
    {
        /*通过两点一线的数学公式可以计算出当前点的下一个点
         * 如果当前点是终点，则返回null;
         * 如果当前点不是线上的点，则抛异常。
         * */
    }
}

class Ball
{
    private Rope rope;
    private Point currentPoint;
    public Ball(Rope rope, Point currentPoint)
    {
        this.rope = rope;
        this.currentPoint = currentPoint;
    }


    public void move() //设置为定时器，每隔1秒move一次
    {
        currentPoint = rope.nextPoint(currentPoint);
        System.out.println("小球移动到了" + currentPoint);
    }
}

【实例 7】：两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材可以做成椅子：
     => 对象：stone  （自己变成石刀，自己都没有了，所以不是自己的方法）
         stoneknife => stoneKnife = KnifeFactory . createKnife( Stone first, Stone second )
         tree
         material  => material = stoneKnife . cut( tree )
         chair    => chair = ChairFactory . createChair( material )

【面向对象的三个特征】

面向对象的三个特征：封装，继承，多态。

开发时：找对象，建对象，用对象，并维护对象之间的关系。

二. 类与对象的关系：

1. 类与对象的关系

1. 类就是对现实生活中事物的描述。
2. 对象就是这类事物，实实在在的个体。

【分析】：张三，李四	【映射到内存中】：
现实生活中的对象：张三，李四。 对象：在Java中用new操作符所产生的一个实体，这个实体在堆内存中。	一个实体（具体对象）
想要描述：提取对象中共性内容，对具体的抽象 描述时，这些对象的共性有：姓名，年龄，性别，学习Java的能力。	一个类（class定义的类）

【实例】：需要描述汽车，描述事物 其实就是描述事物的属性和行为。

1. 【描述事物】：定义类
2. 【属性和行为】：类中的成员（成员变量，成员函数）
3. 【属性】：类中的变量
4. 【行为】：类中的函数

public class CarDemo {
   

    public static void main(String[] args) {
        //生产汽车，在Java中通过new操作符来完成，其实就是在堆内存中产生一个实体。‘

        Car c = new Car(); 
        //c 是引用类型变量，就是类类型变量，指向对象，即指向该类产生的实体。
    }

}

class Car
{
    String color = "red"; //描述颜色
    int num = 4; //描述轮胎数

    /**
     * 运行行为
     */
    public void run() 
    {
        System.out.println(color + "..." + num);
    }
}

2. 对象的内存分配

【实例 1】对象的内存分配情况一。



【分析】：

1. [ new Car( ) ]：新建一个实体。
2. 堆内存中的变量都有一个特点：默认初始化值。
   如果c.color没有显示初始化值，它的默认初始化值为null（因为字符串默认初始化值为null）。

【实例 2】对象的内存分配情况二。



【分析】：

1. [ Car c1 = c ] ：叫多引用指向同一对象
2. [ c1.run( ) ]：结果为 color = “green”;  num = 5;

【总结】：
1. 对象的特点：用于封装数据（属性，行为）
2. 类不独立运行可以没有主函数，在主函数中建立类的对象，可以调用该类中的属性方法。
3. 【成员变量与局部变量的区别】：	（1）作用不一样：	成员变量：作用于整个类
		局部变量：作用于函数中，或者语句中
	（2）在内存中的位置：	成员变量：在堆内存中，因为对象存在才在内存中存在。
		局部变量：存在栈内存中

class Car
{
    String color = "red"; //描述颜色
    int num = 4; //描述轮胎数  【？】

    /**
     * 运行行为
     */
    public void run()
    {
        System.out.println(color + "..." + num); //成员变量作用在整个类中，可以直接访问。
    }

    /**
     * 在本类中创建本类对象
     */
    public static void main(String[] args)
    {
        Car c = new Car();
        c.num = 10;  //这个变了，但是【？】处没变，相当于car变了，图纸没变。
    }
}

3. 匿名对象

对象可以起名字，也可以不起名字。匿名对象是对象的简写形式。

【匿名对象的使用方式】：
【方式 1】	（1）当对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。 【实例】：    Car c = new Car( );    c.num = 5;  => new Car( ).num = 5;
	（2）如果对一个对象进行多个成员调用，必须给这个对象起名字。 【实例】：内存泄露
【方式 2】	匿名对象可以作为实际参数进行传递。 【实例】：汽车修配厂，对汽车进行改装，将来的汽车都改成黑色，三个轮胎。 1. [ 法一 ]：没有采用匿名对象。 【分析】：show 运行结束完，对象c 还被main引用，当mian结束才变为垃圾。要提前变为垃圾：c = null; 2. [ 法二 ]：采用匿名对象。 【分析】：  （1）[ show( Car c){ } ]：相当于Car c = new Car( ); 堆内存中的new Car( )不是垃圾，被show中的c 引用。  （2）当show运行结束后，show为垃圾，实际参数的匿名对象没有引用，也变为垃圾。

三. 封装：

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
【封装体】：	函数就是最小的封装体，类也是封装体，包，框架（用于组件的开发）等。
【好处】：	将变量隔离，便于使用，提供重用性，提高安全性。
【原则】：	将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
【private】：	私有，权限修饰符：用于修饰类中的成员（成员变量， 成员函数），私有只有在本类中有效。

【实例 1】：将年龄私有化

public class Demo {

    public static void main(String[] args) {
        Person p = new Person();
//      p.age = -20;  //访问不到
        p.speak();

    }
}
class Person
{
    private int age;

    public void speak()
    {
        System.out.println("age=" + age);
    }
}

【实例 2】：将age私有化以后，类以外即使建立对象也不能直接访问，但是人应该有年龄，就需要在Person类中提供对应访问age的方法。

1. set返回值类型肯定是void，只设置不需要返回值，带参数。
2. get没有参数，只获取，而且get的返回值类型和获取的变量一样。
3. 一个类里面在setXXX，getXXX功能，代表这个类里边一定有一个私有的属性XXX。