面向对象

面向对象

1.new对象的过程：

2.this关键字：当前对象

//访问当前对象的属性
this.属性名
//访问当前对象的方法
this.方法名
//构造函数之间互相调用，注意必须放在构造函数的第一行
this(...);
//返回当前对象
return this;
//this不能写在普通方法中，只能存在于构造函数中

3.构造函数（Constructor）

（构造器，构造方法）

作用：初始化对象

public class Product {
    private int proId;
    private String proName;
    private float proPrice;

    // 默认省略了 无参构造函数
    public Product(){
        System.out.println("Product的无参构造函数");
    }

}

/* =================================测试类 ================================= */

public static void main(String[] args) {
        new Product();  // 调用 Product的无参构造函数
}	

/*
	创建对象的步骤
	
	1. new 开辟堆内存
	2. 初始化对象的属性（构造函数）
	3. 执行构造函数的方法体

*/

注意：如果类中写了有参构造函数了，那么原先的无参构造函数会被覆盖，所以当写了有参构造函数时，要将无参构造函数也一起写出来。

4.方法重载（Overload）

同样的功能，要求参数列表不一样===方法重载overload

语法要求：

1.方法名相同
2.参数列表不一样
	（1）类型不一样；
	（2）个数不一样；
	（3）当参数列表数据类型不一致时，顺序不一样。

使用场合【重点】

同样的功能，已有的参数列表不满足需求，需要重新载入新的方法（方法名相同，参数列表不一样）

public int add(int a,int b){
        return 0;
    }

    public float add(float a,float b){
        return 0;
    }

    public int add(int a,int b ,int c){
        return 0;
    }

    public float add(int a,float b){
        return 0;
    }

    public float add(float a,int b){
        return 0;
    }

5.对象引用

Product p1 = new Product(1001,"枸杞",19.9f);
product p2 =p1;//p2的指针也指向p1的堆内存地址，此时p1和p2都指向同一块堆内存地址
p2.setPrice(21.9f);//此时p1和p2的price都改为了21.9
p2 = null;//指针断开，此时只有p1指向那一块堆内存


p2 = new Product(1002,"洗衣液",45.6f);
p2.setPrice(2.5f);//此时的p2和p1已经不再指向同一块堆内存了，所以p2的price属性修改不影响p1的price的属性值

6.例题

![值传递](C:\Users\Allen\Desktop\学习笔记\Java_Course\值传递.png)//创建Book类
public class Book {
    private String bookName;
    private float bookPrice;

    public Book(){}
    public Book(String bookName,float bookPrice){
        this.bookName = bookName;
        this.bookPrice = bookPrice;
    }
    //get,set方法省略

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public float getBookPrice() {
        return bookPrice;
    }

    public void setBookPrice(float bookPrice) {
        this.bookPrice = bookPrice; 
    }
}
//测试类
public class DataTransfer {
    public  static void main(String[] args){

        DataTransfer dt = new DataTransfer();
        int a = 10;
        int b = 20;
        dt.fun1(a,b);
        System.out.println("a = " + a + ", b = " + b);

        Book book = new Book("四大名著全套",199.9f);
        dt.fun2(book);
        System.out.println("书的名称："+ book.getBookName() +  ", 书的价格：" + book.getBookPrice());
    }


    public void fun1(int x, int y){
        x = 30;
        y = 40;
    }

    public void fun2(Book book){
        book.setBookName("毛泽东选集");
        book.setBookPrice(99.9f);
    }
}

结果为a = 10,b = 20;
书的名称：毛泽东选集，书的价格：99.9

分析

7.父类转换为子类

（1）父类引用子类对象

 父类类型 = 子类对象//（子类对象可以直接转换为父类类型）
     例如：
     Pet pet = new Dog();
	Object object = new Dog();//父类引用子类对象

（2）父类 不可以 直接 转换为子类对象

例如：
Dog dog = (Dog)new Pet();//虽然IDEA检测正常，但是编译会出异常（ClassCastException:类型转换异常）
//分析：
new Pet()，在堆内存中开辟了一块Pet类型的，此时用Dog类型的dog变量来指向这块堆内存，显然无法接收，因为子类无法接收父类的对象。

在进行强制转换之前，需要进行判断是否为可以接收的类型（关键字：instanceof 判断是否为可接收的对象，返回布尔类型的值）

if(pet instanceof  Dog)
    Dog dog = (Dog)pet;

在堆内存中开辟了一块Pet类型的，此时用Dog类型的dog变量来指向这块堆内存，显然无法接收，因为子类无法接收父类的对象。

###### 在进行强制转换之前，需要进行判断是否为可以接收的类型（关键字：instanceof   判断是否为可接收的对象，返回布尔类型的值）
Pet pet  = new Dog();
if(pet instanceof  Dog)
    Dog dog = (Dog)pet;