java面向对象--05

面向对象概念

面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。

面向过程：

强调的是功能行为。代表语言：C语言。

例子：把大象装进冰箱

1. 打开冰箱。

2. 存储大象。

3. 关上冰箱。

“打开”、”存储”、”关上”都是功能行为，在代码中的直观体现就是函数或者方法，这就是一种面向过程的以功能行为为主体的思想体现。

面向对象：

将功能封装进对象，强调具备了功能的对象。代表语言：Java、C++、C#。

例子：把大象装进冰箱

1. 冰箱打开。

2. 冰箱存储。

3. 冰箱关闭。

可以看到，所有的操作都是以”冰箱”为主体，冰箱就是对象。而不是功能行为。也就是说冰箱自己已经具备”打开”、”存储”、”关上”的行为功能，我们只需要让冰箱执行它具备的功能就可以了。

面向对象是基于面向过程的

面向对象三大特征：封装 继承 多态

以后开发，就是找对象使用，没有对象，就建立一个对象

找对象，建立对象，使用对象，维护对象之间的关系

类与对象之间的关系

类就是：对现实生活中事物的描述

对象：就是这类事物实实在在的个体

例如：图纸和汽车




可以理解为：类就是图纸，汽车就是堆内存中的对象。

对于同一类事物可以抽取它们的共性的内容，定义在类中。如：生活中的汽车，每一台车都有轮胎数和颜色。

那么在通过java描述汽车这类事物时，就可以将这两个共性属性作为类中的属性进行定义。

通过该类建立的每一个汽车实体都具有该属性，并可以有对象特有的属性值。

类的定义

生活中描述事物无非就是描述事物的属性和行为。如：人有身高，体重等属性，有说话，打球等行为。

Java中用类class来描述事物也是如此。

属性：对应类中的成员变量。

行为：对应类中的成员函数。

定义类其实在定义类中的成员(成员变量和成员函数)。

成员变量和局部变量的区别

作用范围：

成员变量作用于整个类中。

局部变量作用于局部范围，函数中，或者语句中。

在内存中的位置：

成员变量在堆内存中，因为对象的存在，才在内存中存在。

局部变量在栈内存中，作用的范围结束，变量空间会自动释放。

初始化值：

成员变量有默认初始化值。

局部变量没有默认初始化值。

匿名对象

匿名对象是对象的简化形式。

匿名对象两种使用情况：

1. 当对对象方法仅进行一次调用时；

2. 匿名对象可以作为实际参数进行传递。

[code]new Car();
//这就是匿名对象
Car c = new Car();
//这个对象就有名字c

对一个对象进行多个成员调用，必须给这个对象起名字

封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

（说白了就是把功能包装起来，便于使用。）

好处：

1. 将变化隔离。

2. 便于使用。

3. 提高重用性。

4. 提高安全性。

封装原则：

1. 将不需要对外提供的内容都隐藏起来。

2. 把属性都隐藏，提供公共方法对其访问。

public：权限共有

private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）

不希望别人直接访问赋值，需要通过私有化把属性进行隐藏

私有只在本类中有效

私有化以后，类以外就算建立了对象也不能直接访问

封装不是私有的，私有只是封装的一种表现形式

[code]class Person
{
    private int age;
    void speak()
    {
        System.out.println("age="+age);
    }
}
class  PersonDemo
{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.age = 20;
        p.speak();
    }
}

结果：


如果类中有属性被私有修饰，一般用setAge与getAge来获得这个属性

代码体现为：

[code]class Person
{ 
    private int age ;
    //通过提供set、get公共方法对其访问
    public void setAge( int a)
    {
        //在set方法内可以对属性的赋值进行限制
        if (a > 0 && a < 130)
        {
            age = a;
        }
        else
        System.out .println("非法的数据" );
    }
    public int getAge()
    {
        return age ;
    }

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

class PersonDemo
{
    public static void main(String[] args)
    {
        Person p = new Person();
        //通过其他方式访问
        p.setAge(20);
        p.speak();
        //赋值不合法，set方法就不允许成功赋值
        p.setAge(-20);
    }
}

用一个fangfa函数简化

[code]class Person
{
    private int age;

    public void fangfa(int a)
    {
        if(a>0&&a<130)
        {
            age = a;
            speak();
        }
        else
            System.out.println("feifa");
    }

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

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

私有后对外提供访问方式，因为可以在访问方式中加入逻辑判断等语句

对访问的数据进行操作，提高代码的健壮性。

构造函数

特点：

1，函数名与类名相同

2，不需要定义返回值类型

跟void不一样，void是一种返回值类型，代表没有具体返回值的情况

3，不可以写return语句

[code]class Person
{
    Person()
    {
        System.out.println("person run");
    }
}
class PersonDemo2
{
    public static void main(String[] args)
    {
        Person p = new Person();

    }
}

运行结果：person run

对象一建立就会立即调用与之对应的构造函数

作用：

给对象进行初始化

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认的给该类加入一个空参数的构造函数

以person为例

[code]class Person
{
    person(){}
}

当一个类中自定义了构造函数后，默认的构造函数就没有了

构造函数和一般函数在写法上有不同

在运行上也有不同

构造函数是在对象一建立就运行，给对象初始化

而一般方法是对象调用才执行，是给对象添加对象具备的功能

一个对象建立，构造函数只运行一次。

而一般方法可以被该对象调用多次

什么时候定义构造函数呢

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

注意：

1，默认构造函数的特点

2，多个构造函数是以重载的形式存在的

重载：函数名相同，参数列表不一样

构造函数函数名都与类名相同，所以可以重载。

只要括号里面的参数列表不同即可



这就是构造函数参数列表不同，显示结果的不同

[code]class Person
{
    private String name;
    private int age;
    Person(String n)
    {
        name = n;
        System.out.println("B:name="+name+"...age="+age);
    }

    public void setname(String n)
    {
        name = n;
    }

    public String getname()
    {
        return name;
    }
}
class PersonDemo2
{
    public static void main(String[] args)
    {
        Person p2 = new Person("Mark");
        p2.setname("bushiMark");
        System.out.println(p2.getname());
    }
}

用setName和getName改名字

构造代码块

作用：给对象进行初始化

对象一建立就运行，而且优先于构造函数执行

和构造函数的区别：

构造代码块是给所有对象进行统一初始化

而构造函数是给对应的对象初始化

构造代码块定义的是不同对象共性的初始化内容

[code]class Person
{
    private String name;
    private int age;

    {
        System.out.println("person run");//构造代码块，给所有对象进行初始化
    }//cry也可以放在构造代码块中   因为它是共性  每次都显示 
}

每一个建立的对象都会执行System.out.println(“person run”)这个操作。这就是构造代码块的作用。

this关键字

this：即代表本类的对象。

代表它所在函数，所属对象的引用

简单说，哪个对象在调用this所在的函数，this就代表哪个对象。

this.name：对象的name

代码体现：

[code]class Person
{
    private String name;
    Person(String name)//这个name跟下面等号右边的name是同一个
    {
        this.name = name;
        //运行p的时候，this.name其实就代表p.name，this就带表对象p
    }
}
class PersonDemo3
{
    public static void main(String[] args)
    {
        Person p = new Person("lisi");  
    }
}

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示该对象

但凡本类功能内部使用到了本类对象，都用this表示

[code]class Person
{
    private String name;
    private int age;

    Person(int age)
    {
        this.age = age;
    }
    /*
    需求：比较是否是同龄人
    */
    public boolean compare(Person p)
    {
        return this.age == p.age;
    }
}

class PersonDemo3
{
    public static void main(String[] args)
    {
        Person p1 = new Person(20);
        Person p2 = new Person(25);
        boolean b = p1.compare(p2);
    }
}

this语句：用于构造函数之间进行相互调用

this语句只能定义在构造函数的第一行。因为初始化动作要先执行。

[code]class Person
{
    private String name;
    private int age;

    Person(String name)
    {
        this.name = name;
    }
    Person(String name,int age)
    {
        //this.name = name;
        //Person(name);调用，构造函数间，不能这样写。只能写this()
        this(name);//就是p(name);
        this.age = age;
    }
}

class PersonDemo4
{
    public static void main(String[] args)
    {
        Person p = new Person("lisi",30);
    }
}