java面向对象--05

面向对象概念

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

面向过程：
强调的是功能行为。代表语言：C语言。

例子：把大象装进冰箱
1. 打开冰箱。
2. 存储大象。
3. 关上冰箱。
“打开”、”存储”、”关上”都是功能行为，在代码中的直观体现就是函数或者方法，这就是一种面向过程的以功能行为为主体的思想体现。

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

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

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

面向对象三大特征：封装 继承 多态
以后开发，就是找对象使用，没有对象，就建立一个对象
找对象，建立对象，使用对象，维护对象之间的关系

类与对象之间的关系

类就是：对现实生活中事物的描述
对象：就是这类事物实实在在的个体
例如：图纸和汽车

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

对于同一类事物可以抽取它们的共性的内容，定义在类中。如：生活中的汽车，每一台车都有轮胎数和颜色。
那么在通过java描述汽车这类事物时，就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性，并可以有对象特有的属性值。

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

Java中用类class来描述事物也是如此。
属性：对应类中的成员变量。
行为：对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。

---

成员变量和局部变量的区别
作用范围：
成员变量作用于整个类中。
局部变量作用于局部范围，函数中，或者语句中。
在内存中的位置：
成员变量在堆内存中，因为对象的存在，才在内存中存在。
局部变量在栈内存中，作用的范围结束，变量空间会自动释放。
初始化值：
成员变量有默认初始化值。
局部变量没有默认初始化值。

匿名对象
匿名对象是对象的简化形式。
匿名对象两种使用情况：
1. 当对对象方法仅进行一次调用时；
2. 匿名对象可以作为实际参数进行传递。

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

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

封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
（说白了就是把功能包装起来，便于使用。）
好处：
1. 将变化隔离。
2. 便于使用。
3. 提高重用性。
4. 提高安全性。

封装原则：
1. 将不需要对外提供的内容都隐藏起来。
2. 把属性都隐藏，提供公共方法对其访问。

public：权限共有
private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）
不希望别人直接访问赋值，需要通过私有化把属性进行隐藏
私有只在本类中有效
私有化以后，类以外就算建立了对象也不能直接访问
封装不是私有的，私有只是封装的一种表现形式

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来获得这个属性
代码体现为：

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函数简化

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语句

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

    }
}

运行结果：person run

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

作用：
给对象进行初始化

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

以person为例

class Person
{
    person(){}
}

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

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

在运行上也有不同
构造函数是在对象一建立就运行，给对象初始化
而一般方法是对象调用才执行，是给对象添加对象具备的功能

一个对象建立，构造函数只运行一次。
而一般方法可以被该对象调用多次

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

注意：
1，默认构造函数的特点
2，多个构造函数是以重载的形式存在的

重载：函数名相同，参数列表不一样
构造函数函数名都与类名相同，所以可以重载。
只要括号里面的参数列表不同即可

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

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改名字

构造代码块
作用：给对象进行初始化
对象一建立就运行，而且优先于构造函数执行
和构造函数的区别：
构造代码块是给所有对象进行统一初始化
而构造函数是给对应的对象初始化
构造代码块定义的是不同对象共性的初始化内容

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
代码体现：

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表示

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语句只能定义在构造函数的第一行。因为初始化动作要先执行。

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);
    }
}