java基础学习05(面向对象基础01)

面向对象基础01

1.理解面向对象的概念 
2.掌握类与对象的概念
3.掌握类的封装性
4.掌握类构造方法的使用

实现的目标

1.类与对象的关系、定义、使用 
2.对象的创建格式，可以创建多个对象
3.对象的内存分配过程

面向对象与面向过程

比如一个木匠要做一个盒子，那么这个盒子的出发点会有两种方式。
面向对象：先想好要做的盒子，之后再去找相应的工具去做好这个盒子。需要一系列完整的设计，同时取出所要用到的工具。
面向过程：不去想要做什么样的盒子，随需取用工具。

面向对象的三大特征：
封装（encapsulation）--对外部不可见
继承（inheritance）--扩展类的功能
多态（polymorphism）--方法的重载、对象的多态性

类与对象的关系

在面向对象中，类和对象是最基本、最重要的组成单元。类是相同特性和行为的对象集合。类可以理解某类事物的共性，对象就是一个具体的东西。

类的定义

class 类名称{
数据类型  属性 ;//声明成员变量（属性）
….   

public 返回值的数据类型 方法名称（参数1，参数2…）{//定义方法的内容
        程序语句 ;
        [return 表达式;]
    }
}

对象的创建和使用

    类名 对象名 = null;  //声明对象
    对象名称 =new 类名();//实例化对象
或
    类名 对象名 = new 类名();

访问属性：对象名称.属性名
访问方法：对象名称.方法名

定义一个Person类，包括名字、年龄、tell()。

/**
*1.定义一个Person类（未封装）
*/
  class Person{
    String  name;       //属性 名字
    int     age;        //属性 年龄

    public void tell(){
        System.out.println("我的姓名叫："+name+"今年"+age);
    }
}

class TestDemo01{
    public static void main(String [] args){
        Person per = new Person();//实例化对象
        per.name = "张三";
        per.age = 30;
        per.tell();
    }
}

Process started >>>
我的姓名叫：张三,今年30
<<< Process finished. (Exit code 0)

对象的实例化是要划分堆和栈空间，分配内存如下图。所有的对象名称都在栈内存中保存，属性都保存在堆内存中，必须使用new关键字才能开辟堆内存空间。 

属性赋值完后的内存空间。

对象使用之前必须进行实例化，否则（Person per = null）将会现空指向异常(Exception in thread "main" java.lang.NullPointerException)

多个对象的创建及对象引用传递
类属于引用数据类型，引用数据类型就是指一段内存空间可以被多个栈内存指向。

/**
*1.对象引用传递（引用传递是将一个堆内存空间的使用权给多个栈内存空间，
*  每个栈内存空间都可以修改堆内存空间的内容）
*/

class Person{
    String  name;       //属性 名字
    int     age;        //属性 年龄

    public void tell(){
        System.out.println("我的姓名叫："+name+",今年"+age);
    }
}

class TestDemo01{
    public static void main(String [] args){
        Person per1 = new Person();
        Person per2 = new Person();

        per1.name = "张三";
        per1.age = 30;

        per2.name = "李四";
        per2.age = 33;
        per2 = per1;                    //将per1的引用传递给per2
        System.out.println("per1对象的内容：");
        per1.tell();
        System.out.println("per2对象的内容：");
        per2.tell();
    }
}

Process started >>>
per1对象的内容：
我的姓名叫：张三,今年30
per2对象的内容：
我的姓名叫：张三,今年30
<<< Process finished. (Exit code 0)

一个栈内存空间只能指向一个堆内存空间，如果要想再指向其它的堆内存空间，则必须先断开已有的指向才能分配新的空间。 关于垃圾空间的释放：java本身提供垃圾收集机制(Garbage Collection),会不定期的释放不用的内存空间，只要对象不使用了，就会等待GC释放空间。

封装性

什么叫封装性？就是对外部不可见。私有属性不能通过对象直接访问。只要是被封装的属性，则必须通过setter和getter方法取得。

为属性封装： private 属性类型 属性名称
为方法封装： private 方法返回值 方法名称(参数列表){}

1.在开发中，类中全部属性都必须封装，封装之后的属性必须通过getter和setter进行访问。
2.用private属性或方法只能在其类的内部被调用，而不能在类的外部被调用。

3.类中的方法直接写上方法名称就可以完成本类中的方法调用，若非要强调是本类中的方法，可使用this.方法名称()。

根据类图实现如下代码：

/**
*1.封装性(private)
*/

class Person{
    private String  name;       //属性 名字
    private int     age;        //属性 年龄

    public void tell(){
        System.out.println("我的姓名叫："+this.getName()+",今年"+this.getAge());
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        if(age>0 && age<150){
            this.age = age;
        }
    }
    public int getAge(){
        return this.age;
    }
}

class TestDemo01{
    public static void main(String [] args){
        Person per1 = new Person();
        Person per2 = new Person();

        per1.setName("张三");
        per1.setAge(30);
        per2.setName("李四");
        per2.setAge(33);
        System.out.print("未将per1的引用传递给per2对象的内容：");
        per2.tell();
        per2 = per1;                //将per1的引用传递给per2
        System.out.print("per1对象的内容：");
        per1.tell();
        System.out.print("将per1的引用传递给per2对象后的内容：");
        per2.tell();
    }
}

构造方法

在面向对象程序中构造方法的主要作用是为类中的属性初始化，通过构造方法可以在对象实例化时就直接把对象的值赋给属性。

构造方法的定义

class 类名称{
    访问权限 类名称(类型1 参数1，类型2 参数2){
        程序语句;
        ... // 构造方法没有返回值
    }
}

构造方法声明牢记以下三点：
1.构造方法的名称必须与类名称一致 
2.构造方法的声明处不能有任何返回值类型的声明（void也不能写） 
3.不能在构造方法中使用return返回一个值

需要注意的是，调用new关键字实例化对象时(per = new Person())才会调用构造方法。只要是类就必须存在构造方法，在Java中如果一个类中没有明确声明一个构造方法，则在编译时会直接生成一个无参数的、什么都不做的构造方法。如果声明了一个构造方法，则程序在编译时不会再生成默认的构造方法。

/**
*1.构造方法(Constructor)
*/

class Person{
    private String  name;       //属性 名字
    private int     age;        //属性 年龄

    public void tell(){
        System.out.println("我的姓名叫："+this.getName()+",今年"+this.getAge());
    }

    public Person(){

    }

    public Person(String name){
        this.setName(name);
    }

    public Person(String name,int age){  //定义构造方法为属性初始化
        this.setName(name);              //为name属性赋值
        this.setAge(age);                //为age属性赋值
    }

    public void setName(String name){   //设置姓名
        this.name = name;
    }
    public String getName(){            //取得姓名
        return this.name;
    }
    public void setAge(int age){        //设置年龄
        if(age>0 && age<150){
            this.age = age;
        }
    }
    public int getAge(){                //取得年龄
        return this.age;
    }
}

class TestDemo01{
    public static void main(String [] args){
        Person per1 = new Person("张三",30);
        Person per2 = new Person();

        per2.setName("李四");
        per2.setAge(33);
        System.out.print("未将per1的引用传递给per2对象的内容：");
        per2.tell();
        per2 = per1;                //将per1的引用传递给per2
        System.out.print("per1对象的内容：");
        per1.tell();
        System.out.print("将per1的引用传递给per2对象后的内容：");
        per2.tell();
    }
}

匿名对象

匿名对象就是没有给出名字的对象。一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存引用。

class TestDemo01{
    public static void main(String [] args){
        new Person("张三",30);    //匿名对象
    }
}