本文已参与「新人创作礼」活动，一起开启掘金创作之路。

面向对象(OOP)下

1、对象与引用

在Java中除基本数据类型外，其他都是引用类型。

Java中的对象通过引用对其操作。

public staitc void main(){
    //Book b=new Book();//创建一个Book类的对象b
    Book b;//对象引用
    b=new Book();//对象本身
    /*
    new Book():调用构造方法，在堆里创建一个Book类的对象
    Book b:创建了一个Book类型的引用变量
    =：将对象引用指向创建的对象
    */
}
class Book{//书本类
double price;
String author;
}

匿名对象&实名对象

package Test;
public class test {
    public static void main(String args[]){
    /*
    创建Book类的对象
    */
        new Book();//匿名对象：只通过new在堆内存中开辟了空间，未将地址赋给栈内存中某个变量
        Book b=new Book();//实名对象
        //实名对象引用
        b.setPrice(30);
        b.display();
        //匿名对象引用
        new Book().setPrice(50);
        new Book().display();
    }
}
class Book{//书本类
    double price=10;
    String author="佚名";
    String name="三体";
    public void setPrice(double p){//改定价
        price=p;
        System.out.println(price);
    }
    public void display(){
        System.out.println(author+" "+name+" "+price);
    }
}

运行结果：

可以看到实名对象（在栈内存中有变量指向对象的地址）多次操作可以保存。

而匿名对象操作后的记录不会保留，下次再使用时，已经不是同一个对象。

匿名对象的特点：

由于没有记录堆内存对象的地址值，所以只能用一次。

匿名对象的好处：使用完毕就是垃圾，可以在垃圾回收器空闲时回收，节省内存空间。

2、访问权限修饰符

修饰符的修饰范围

修饰范围	public	protected	default	private
类	✓		✓
属性	✓	✓	✓	✓
方法	✓	✓	✓	✓

修饰符的访问范围

	public	protected	default	private
同类	✓	✓	✓	✓
同包	✓	✓	✓
不同包的子类	✓	✓
不同包其他类	✓

package JavaSE.JavaOOP.pactest;
public class packagetest {
    public static  int a=10;
    protected static  int b=10;
    static int c=10;//缺省
    private static int d=10;
    public static void main(String[] args) {
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

运行结果：

package JavaSE.JavaOOP.pactest;
public class test1 {
    public static void main(String[] args) {
        packagetest p=new packagetest();
        System.out.println(p.a);
        System.out.println(p.b);
        System.out.println(p.c);
        //System.out.println(p.d);  private修饰的只能在本类中访问
        //报错;'d' has private access in 'JavaSE.JavaOOP.pactest.packagetest'
    }
}

package Test;
import JavaSE.JavaOOP.pactest.packagetest;
public class pactest2 extends packagetest{
    public static void main(String[] args) {
        packagetest p=new packagetest();
        System.out.println(p.a);//public任何情况都可访问
        System.out.println(p.b);//protected修饰的在同包/同类/不同包子类中访问
        //System.out.println(p.c);default修饰的只能在同包中访问
        //System.out.println(p.d);  private修饰的只能在本类中访问
    }
}

3、包（package）

包：类所在的路径，类似于文件夹在电脑中的位置。

包的作用：

1. 按功能管理分类，方便查找使用

2. 采用树形目录存储方式，可以避免类的重名问题

3. 进行访问权限控制

包的语法格式：

package 一级包.二级包.N级包 ; 精确定位到某一个类

包的导入;

关键字：import

import java. 一级包.二级包.xx类； 加载当前类

import java. 一级包.*； 加载当前包中所有类

package JavaSE.JavaOOP.pactest;

import java.util.Date;
//import java.sql.Date;
/*
    从java角度，包是路径，位置
    全类名=包名+类名简称
    
    报错:'java.util.Date' is already defined in a single-type import
    不能用import同时导入两个及以上不同路径,相同类名的类
    若需使用两同名类:
    一个用import导入  import java.util.Date;
    其他用全类名 如  Date date1 = new java.sql.Date(2500);
 */
public class sameClassName {
    public static void main(String[] args) {
        Date date=new Date();
        Date date1=new java.sql.Date(2500);
    }
}

4、封装

封装的好处：

1. 隐藏信息（权限），提供特定方法访问

2. 类内部结构可自由修改

3. 对成员变量进行精确控制

package JavaSE.JavaOOP.fz;
public class Book {
    private String name;//书名
    private String author;//作者
    private double price;//定价
    private char ch ;//
    private Book(){}//私有化构造方法
    //获取Book类的对象
    public static Book getBookObject(){
        if(book==null){
            book=new Book();
        }
        return book;
    }
    //修改定价
    public void setPrice(double p){
            price=p;
    }
    public double getPrice(){
        return price;
    }
    //修改书名
    public void setName(String n){
        if(n.length()<20&&n.length()>0){
            name=n;
        }

    }
    public String getName(){
        return name;
    }
    //修改作者
    public void setAuthor(String a){
        if(a.length()<15&&a.length()>0){
            author=a;
        }
    }
    public String getAuthor(){
     return author;
    }
    //出版情况
    public void publish(){
        if(name!=null){
            System.out.println(name+"已出版");
        }
        else{
            System.out.println("未出版");
        }
    }
    //显示书本各种信息
    public void display(){
        System.out.println("书名："+name+"\r\n作者:"+author+"\r\n定价:"+price);
        System.out.println(name+"已出版\r\n");
    }
}

package JavaSE.JavaOOP.fz;
public class test1 {
    //单例模式：在程序中运行过程中，只创建一个对象
    public static void main(String[] args) {
        Book b = Book.getBookObject();//通过方法来实例化对象
        b.setAuthor("孙武");
        b.setName("孙子兵法");
        b.setPrice(36.8);
        b.display();
    }
}

运行结果: