Java基础-05-面向对象

Java基础-面向对象

面向对象入门

1、面向对象概述

（1）、理解面向对象：一种思考思想。如图：

（2）、面向对象的优点：

复杂的事情变简单。（以前：执行 。现在：指挥）

2、面向对象（举例）

JAVA----->一切皆对象

3、面向对象（类与对象的关系）

（1）、例如：人开门（名词提炼法）

人{        开门(门){门.开();}         }
门
{
        开(){操作门轴等}
}

（2）、

• 面向对象有3个特征：封装、继承、多态。
• 以后开发：其实就是找对象使用，没有对象，就创建一个对象，即找对象，建立对象，使用对象，维护对象的关系。

• 类和对象的关系：

    类：就是对现实生活中的事物的描述。
    对象：就是这类事物，实实在在存在的个体。例如：张三、李四。（现实生活中的对象）
  

• 想要描述：提取对象中共性的内容，对具体的抽象描述时，这些对象的共性有：姓名，年龄，性别，学习的功能等。映射到JAVA中，描述就是class定义的类，具体对象就是对应JAVA在对内存中建立的实体。
• 例如：定义一个需求：描述汽车（颜色...等）。描述事物其实就是在描述事物的属性和行为。 该需求的类和对象的关系：如图：

属性对应类中的变量，行为对应类中的函数（方法）。其实定义类就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员（成员的变量和方法） Eg：

public class Demo1
 {
    public static void main(String []args)
    {
        //生产汽车，在Java中通过new操作符来完成
        //其实就是在对内存中产生一个实体
        Car c = new Car();    //c就是一个类类型变量
        //记住类类型变量指向对象
        //需求：将已有车的颜色改成蓝色，指挥该对象使用方法，在Java指挥就是：对象.对象成员/对象.对象方法
        c.color = "蓝色";
        c.run();
        Car c1 = new Car();
        c1.run();      //color :红色，4
    }
}

class Car 
{
    //描述颜色
    String color = "红色";
    //描述轮胎数
    int num = 4;
    //运行行为、
    void run ()
    {
        System.out.println(color+".."+num);
    }
}

以上程序可以用下图来表示：如图

Eg：思考一下以下例子

public class Demo1 {
    public static void main(String []args)
    {
        Car c = new Car();
        c.num = 5 ;
        Car c1 = c ;         //对象间赋值
        c1.color = "绿色";
        c.run();            //绿色  5
    }
}

class Car 
{
    //描述颜色
    String color = "红色";
    //描述轮胎数
    int num = 4;
    //运行行为
    void run ()
    {
        System.out.println(color+".."+num);
    }
}

输出的结果是绿色 5 原因如下图

4、面向对象（成员变量和局部变量）

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

• 成员变量：作用于整个类中，并且生存于堆内存中。

• 局部变量：作用于函数或语句中并且生存于栈内存中。

5、面向对象（匿名对象的应用）

什么是匿名对象：是对象的简化形式。

（1）、匿名对象使用方法一：当对象的方法只调用一次时，可以使用匿名对象来完成，这样写比较简化，但如果对一个对象进行多个成员调用，必须给这个对象起个名字。

Eg

public class Demo1 {
    public static void main(String []args)
    {
        //Car c = new Car();
        //c.num = 5 ;
        new Car().num = 5 ;
        new Car().color = "蓝色";
        new Car().run() ;   //结果是:红色..4  
    }
}

class Car 
{
    //描述颜色
    String color = "红色";
    //描述轮胎数
    int num = 4;
    //运行行为、
    void run ()
    {
        System.out.println(color+".."+num);
    }
}

为什么程序的结果不是红色..5或者是蓝色..4呢？而结果却是红色..4？

看图来观察原因：

从图中可以看出，用匿名对象去调用多个成员时，是相当于在调用时独立创建一个新的对象然后进行调用的，因此如果对一个对象进行多个成员调用，必须给这个对象起个名字。

（2）、匿名对象的使用方式二：可以将匿名对象作为实际参数进行传递。

Eg1：（正常没用使用匿名对象作为实际参数进行传递的例子）

public class Demo1 
{
    //需求：汽车修配厂，对汽车进行改装，将来的汽车都改成黑车，三个轮胎。
    public static void show (Car c)
    {
        c.num = 3 ;
        c.color = "黑色";
        c.run();
    }
    public static void main(String []args)         //主函数
    {
        Car q = new Car();
        show(q);
    }
}

class Car 
{
    //描述颜色
    String color = "红色";
    //描述轮胎数
    int num = 4;
    //运行行为、
    void run ()
    {
        System.out.println(color+".."+num);
    }
}

程序概况如图所示：

Eg2：（以下例子是匿名对象作实际参数）

public class Demo1 
{
    //需求：汽车修配厂，对汽车进行改装，将来的汽车都改成黑车，三个轮胎。
    public static void show (Car c)
    {
        c.num = 3 ;
        c.color = "黑色";
        c.run();
    }
    public static void main(String []args)
    {
        show(new Car());          //匿名对象作实际参数
    }
}

class Car 
{
    //描述颜色
    String color = "红色";
    //描述轮胎数
    int num = 4;
    //运行行为
    void run ()
    {
        System.out.println(color+".."+num);
    }
}

程序概况如图所示：

用匿名对象作函数实际参数传递的时候就相当于给函数show内的成员变量赋上匿名对象建立是的地址值。 小技巧：如何让实体变垃圾 Eg:

Car q = new Car();
q = Null;

6、面向对象（封装概述）

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

好处：

（1）、将变化隔离

（2）、便于使用

（3）、提高重用性

（4）、提高安全性

函数就是代码当中最小的封装。 原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方式对其访问。 关键字private：私有

7、面向对象（封装Private）

Eg：

public class Demo1 
{
    public static void main(String []args)
    {
        Person p = new Person();
        p.age = 20;             //由于Person类中的age被定义为私有，所以对象不能直接访问类中的成员变量
        p.speak();
    }
}

class Person 
{
    int private age ;      //age被定义为私有的
    void speak()
    {
        System.out.println("age="+age);
    }
}

因此程序编译时会出现错误提示，说明age不能被对象p直接访问。

private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）。私有只在本类中有效，将age私有化之后，类以外即使建了对象也不能直接访问，但是人应该有年龄，就需要在Person类中提供对应访问age的方式。

注意：封装不是私有，私有仅仅是封装的一种表现形式。

Eg：

public class Demo1 
{
    public static void main(String []args)
    {
        Person p = new Person();
        p.haha(20);          //对象p调用成员方法来访问age
        p.speak();
    }
}

class Person 
{
    private int  age ; 
    public void haha (int a)         //定义了一个方法去访问类中的私有变量
    {
        age = a;
    }
    void speak()
    {
        System.out.println("age="+age);
    }
}

编程习惯：在类中，一般一个变量（属性）对应两个方法（函数）：一个用来获取数值，一个用来设置。

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断语句，对访问的数据进行操作，提高代码的健壮性。

Eg：

public class Demo1 
{
    public static void main(String []args)          //主函数
    {
        Person p = new Person();
        p.setAge(20);                      //调用Person类中的setAge方法，输入年龄
    }
}

class Person 
{
    private int  age ;              //age设置为private，即只能通过类中的方法来访问
    public void setAge(int a )       
    {
        if (a> 0 && a<130)               //在方法中设置if-else语句来进行判断，不在范围内的输出非法age
        {
            age = a;
            speak();
        }
        else System.out.println("非法age");
    }
    public int getAge()             //获取age变量值的方法
    {
        return age ;
    }
    void speak()
    {
        System.out.println("age="+age);
    }
}

8、面向对象（构造函数）

构造函数： 特点

（1）、函数名与类名相同。

（2）、不用定义返回值类型。

（3）、不可以写return语句。

作用：给对象进行初始化。 注意：

（1）、默认构造函数的特点。

（2）、多个构造函数是以重载的形式存在。

构造函数小细节：当对象一建立就会调用与之对应的构造函数，当一个类中没有一个构造函数时，系统会自动默认给该类加入一个空参数的构造函数（例如Person类中对象一建立就默认加入构造函数Person(){}），当在类中自定义了构造函数，系统就不加了。

Eg：

public class Demo1 
{
    public static void main(String []args)
    {
        Person p = new Person();           //建立一个新的Person类对象p
    }
}

class Person 
{
    Person()                    //自定义的构造函数
    {
        System.out.println("Person run!");
    }
}

程序结果：Person run!

该程序当新对象一建立，就马上调用自定义的构造函数Person()，然后输出Person run! Eg:

public class Demo1 
{
    public static void main(String []args)
    {
        Person p1 = new Person();
        Person p2 = new Person("lisi");
        Person p3 = new Person("wangwu",10);
    }
}

class Person 
{
    private String name ;
    private int age;    
    Person()
    {
        System.out.println("A:name = "+name+",age="+age);
    }
    Person(String n)
    {
        name = n;
        System.out.println("B:name = "+name+",age="+age);
    }
    Person(String n , int a)
    {
        name = n ;
        age = a;
        System.out.println("C:name = "+name+",age="+age);
    }
}

输出结果：

A:name = null,age=0
B:name = lisi,age=0
C:name = wangwu,age=10

若把以上程序中Person类中的构造函数Person(){}注销掉，程序会发生什么事情？ 程序会提示编译不通过，因为原本在类中如果没有自定义构造函数，那么系统会默认定义一个构造函数，然后以上程序由于利用函数重载的技术进行了调用构造函数，因而存在了构造函数，所以系统再不会默认定义一个Person(){}的构造函数，因而如果注销了Person(){}构造函数，再输入该命令Person p1 = new Person();去建立一个新对象，程序编译失败。

• 构造函数和一般函数在写法上不同，在运行上也不同。 构造函数：在对象一建立就运行，给对象初始化。而当一个对象建立，构造函数只运行一次。 一般函数：是对象调用才运行，是给对象添加对象具备的功能。一般方法可以被该对象调用多次。

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

9、面向对象（构造代码块）

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

Eg：

public class Demo1 
{
    public static void main(String []args)
    {
        Person p1 = new Person();     //建立新Person对象

    }
}

class Person 
{
    private String name ;
    private int age;    
    Person()        //构造函数
    {
        System.out.println("Person run!");   
    }
    {
        System.out.println("Person code run!");  //构造代码块
    }
}

结果：

Person code run!
Person run!

可见当对象一建立构造代码块就运行，而且先于构造函数。

10、面向对象（this关键字）

注意：若把构造函数私有化，那么对象建立不成功，要注意！ 思考以下代码：

public class Demo1 
{
    public static void main(String []args)
    {
        Person p1 = new Person("lisi");     //建立新Person对象并传入字符串lisi
        p1.speak();     
    }
}

class Person 
{
    private String name ;
    private int age;    
    Person(String name)        //构造函数重载，接收了主函数传来的字符串lisi
    {
        name = name;     //相当于自己赋值给自己，因为函数中的变量是局部变量，所以在
                                        //函数内使用的变量就是局部变量name，而不会自动出去外面寻找另外的name
    }        
    public void speak()
    {
        System.out.println("name = "+name+" age = "+age);
    }
}

所以程序结果是：

name = null age = 0

以上代码出现的问题如何解决？ 我们可以把代码name = name ;改成this.name = name; 完整代码如下

public class Demo1 
{
    public static void main(String []args)
    {
        Person p1 = new Person("lisi");     //建立新Person对象并传入字符串lisi
        p1.speak();     
    }
}

class Person 
{
    private String name ;
    private int age;    
    Person(String name)        //构造函数重载，接收了主函数传来的字符串lisi
    {
        this.name = name;     //改进后的代码段
    }        
    public void speak()
    {
        System.out.println("name = "+name+" age = "+age);
    }
}

程序结果：

name = lisi age = 0

在代码中出现的this代表Person类的对象p。 this：看上去，用于区分局部变量和成员变量同名情况。this代表它所在函数所属对象的引用，简单说：哪个对象在调用this所在函数，this就代表哪个对象。

11、面向对象（this关键字的应用）

需求：给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人。

public class Demo1 
{
    public static void main(String []args)
    {
        Person p1 = new Person(20);          //新建一个p1对象，年龄是20
        Person p2 = new Person(30);          //新建另一个p2对象，年龄是30
        boolean b = p1.compare(p2);           //利用p1对象调用方法compare（），返回boolean的值赋值给b
        System.out.println(b);                          //打印b的值，布尔类型。
    }
}

class Person 
{
    private String name ;
    private int age;    
    Person(int age)        //构造函数重载
    {
        this.age = age;           //应用了this关键字
    }        
    //该函数判断两个人是否同龄
    public boolean compare (Person p)
    {
        if(this.age == p.age)          //if语句里应用了this关键字，p代表p2，而this代表引用了该方法的对象p1
        {
            return true;
        }
        else return false;
    }
}

程序结果：

false

this的应用总结：当定义类中的功能时，该函数内部要调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用到了本类对象，都用this来表示。

12、面向对象（this关键字在构造函数间调用）

之前例子中的改进。

public class Demo1 
{
    public static void main(String []args)
    {
        Person p1 = new Person("lisi",20);
        p1.speak();
    }
}

class Person 
{
    private String name ;
    private int age;    
    Person(String name)        //构造函数重载
    {
        this.name = name;     
    }        
    Person(String name,int age)
    {

        this(name);     //替代了代码this.name = name;这里的this代表Person类，即调用了构造函数Person("lisi")
        this.age = age;
    }
    public void speak()
    {
        System.out.println("name = "+name+" age = "+age);
    }
}

程序结果：

name = lisi age = 20

以上例子是证明this语句用于构造函数之间进行互相调用。 注意一个问题：this语句只能定义在构造函数的第一行，因为初始化要先执行。