JAVA-基础（类与对象）

一.面向过程与面向对象
面向过程：针对某一特定的问题提出的解决方法
面向对象：以一种组件化的思想解决问题
例如：一辆汽车的轮胎发动机坏了，面向过程解决方法是修发动机（因为没有厂家能生产这种发动机），而面向对象的方法是换发动机（有厂家可以生产这种发动机）。
二.类与对象
1.类是对象的模板，对象是类的实例。类不可以直接使用，必须实例化成对象才可以使用。
类： ----------- > 对象：
图纸 ------------> 房子

（1）对象的声明与实例化
栈内存：保存对象属性内容在堆内空间对应的地址<地址可用对象名简化替代>
堆内存：对象属性的内容可以被保存在里面，需要new关键字来开辟堆内存空间，此时对象属性的内容为对应数据类型的默认值。
1）声明并实例化对象

package 类与对象;
class Book
{
    String title;
    double price;
    public void getinfo()
    {
        System.out.println("书名： "+title+" 价格： "+price);
    }
}
public class DEMO1 {

    public static void main(String[] args)
    {
        Book bk = new Book();
        bk.title = "Java开发";
        bk.price = 89.9;
        bk.getinfo();
    }
}

2）先声明再实例化对象
声明对象：此时对象未开辟堆内存空间，如果不进行实例化，会出现空指针异常（NullPointerException）

package 类与对象;
class Book
{
    String title;
    double price;
    public void getinfo()
    {
        System.out.println("书名： "+title+" 价格： "+price);
    }
}
public class DEMO1 {

    public static void main(String[] args)
    {
        Book bk = null;
        bk = new Book();
        bk.title = "Java开发";
        bk.price = 89.9;
        bk.getinfo();
    }
}

（2）对象的引用（引用类似于指针，将一个对象的地址传递给另一个对象）

public class DEMO1 {
    public static void main(String[] args)
    {
          Book booka = new Book();
          Book bookb = null;
          booka.title = "Java开发";
          booka.price = 89.9;
          bookb = booka;//引用
          bookb.price = 69.8;//更改值
          booka.getinfo();

    }
}

一块堆内存地址可以被多个栈内存保存，一块栈内存只能指向一个堆内存的地址！（类似于函数中变量x—>函数y，存在多对一关系，不存在一对多关系。），其中任何一个栈内存所对应的对象更改了堆内存属性的值，其他对象会受到影响

public class DEMO1 {
    public static void main(String[] args)
    {
        Book booka = new Book();
        Book bookb = new Book();
        booka.title = "Java开发";
        booka.price = 89.9;
        bookb.title = "Jsp开发";
        bookb.price = 68.9;
        bookb = booka;//引用
        bookb.price = 100.1;//更改值
        booka.getinfo();

    }
}

在引用数据类型关系中，一块没有任何栈内存指向的堆内存空间就变成了垃圾，会被java（GC垃圾清理器）不定期的清理回收，释放空间！在代码开发中应尽量避免产生垃圾！
（注:以上图片截取李兴华老师上课笔记）

（3）面向对象----封装性+构造方法与重载
1.封装性：把对象属性和行为结合成一个独立的整体，并对外隐藏部分内部细节。有效避免外部错误向向内部传播。
封装用到setter（），getter（）方法

package 类与对象;
class Book1
{
    private String title;
    private double price;
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
}
public class DEMO2 {
    public static void main(String[] args) {
        Book1 bo = new Book1();
        bo.setPrice(100);
        bo.setTitle("java");
        System.out.println(bo.getTitle()+bo.getPrice());
    }


}

（2）构造与重载

package 类与对象;
class Book1
{
    private String title;
    private double price;
    public Book1(){
        System.out.println("无参构造函数");
    }
    public Book1(String t)
    {
        title = t;
        System.out.println("重载1");
    }
    public Book1(String t,double p)
    {
        title = t;
        price = p;
        System.out.println("重载2");
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
}
public class DEMO2 {
    public static void main(String[] args) {
        Book1 bo = new Book1();
        bo = new Book1("python");
        bo = new Book1("c++",100);

    }


}

关于构造与重载几点说明：
1.构造函数在对象被创建（对象实例化 new（））时自动调用，将对象初始化一个特定的状态。与类名相同，无参，无返回值，一般为public类型。构造方法只在实例化对象时调用一次！
2.程序中没有声明构造函数，系统编译时自动产生一个缺省构造方法
3.一旦程序中声明了带参构造函数，系统将不再产生缺省构造方法，此时可以自己声明无参构造方法，实现了重载！
4.构造方法可以重载，保证函数名与类名一致，参数个数或者参数类型不同即可
5.在定义一个类的时候可以为属性赋初始值，这个初始值只有在构造执行完成后才会设置，而构造方法是整个对象构造（实例化）过程中的最后一步（遗留问题）
6.匿名对象： new Book1(“python”).getPrice();匿名对象由于没有其他对象的引用，只能用一次，用完后将成为垃圾等待清理。