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

【分析】:

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

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

对象的内存分配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。
  • 3
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 4
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值