JavaSE关于类和对象

1、类的定义：class 类名

        在java中只有一个public类，这个类名字必须和文件名一致。

        其他类的访问修饰符不能为public。

        类前面没加访问修饰符，是因为在java中不加访问修饰符也是一种修饰符，其为通配符。

        定义类的属性： 访问修饰符 数据类型 属性名 = 属性;

2、如何创建对象：

        定义类，在根据类来创建对象，可以通过类的构造方法来创建对象，使用new关键字

        类名 对象名称 = new 构造函数() ;

        Scanner sc = new Scanner (System. in) ;

        Random random = new Random() ;

3、如何操作【访问，设置】属性和方法：对象.属性

4、被final修饰的变量其值是固定的，不能被重新赋值。

5、重写toString方法：

        该方法在打印对象时，并不会打印对象的属性，而是打印对象的hashcode值（地址），重写toString方法使其打印对象的属性。定义在类里面。

6、类的初始化：构造函数

        构造方法：访问修饰符 类 名称(){}

        在java类中，如果没有自己定义构造函数，系统(Jvm)会自动生成一个无参的构造函数，方便我们构建一个属性都为默认值的对象。但是当我们定义了一个构造函数之后，系统(JVM)将不再自动生成一个无参的构造函数，如果需要这个无参，需要自己定义。

7、构造函数的作用：

        初始化对象属性

8、this指针问题：

        在java中存在this指针关键字，这个关键字在创建对象时自动指向当前对象。

9、类的成员：

属性

方法

构造方法

静态属性

静态方法

构造代码块

静态代码块

10、static关键字：

static关键字可以修饰非常多的东西(如:属性、方法、类、语法块、导包)：

        1-- static可以修饰属性

        2-- static可以修饰方法

        3-- static还可以修饰类，注意，只能修饰内部类

        4-- 静态导包

        5-- static静态代码块

        static修饰的代码，会提前加载到内存中，并且只有一份，属于该类。因此静态方法中，无法直接调用非静态函数(属性)。

被static修饰的属性和方法，不属于对象，属于该类

直接可以使用类名称.属性（方法）来调用。

11、类的成员加载(运行)顺序:

        属性最先运行，之后是构造函数。

        static修饰的属性和静态代码块最先运行(这两者之间看代码顺序),

        之后才开始运行对象属性和构造代码块(这两者之间看代码顺序)，

        最后构造函数开始运行。

12、java中的权限访问修饰符：

        public：在任何地方都可以正常访问该访问修饰符修饰的属性和方法。

        protected：可以在同包、同类、子类中被访问。

        缺省（默认）：可以在同包、同类中访问。

        private：只能在当前类中访问，不能超过该类。

        注意：class类，只能被public和默认访问修饰符访问。

1、面向对象的三大特征：

1--封装

封装：面向对象的封装有两层含义

        1-- 类，属性、方法这些定义在类

        2--为了安全考虑，在开发过程中，会将属性私有化（private关键字修饰），

        需要提供对应接口完成设置和访问（公开的setter和getter方法）的过程。

        私有化构造函数（将构造函数的访问修饰权限设置为private）：

        1--工具类（静态方法或者静态属性）中一般设计为私有构造函数

public class Article { //文章
    private int id;//私有化属性
    private String title;
    private String content;
    private Author author;
    private Date publishTime;
    private Date modifyTime;
    private Board board;

    public Article() {

    }

    public Article(int id, String title, String content, Author author, Date publishTime, Date modifyTime, Board board) {//全参构造函数
        this.id = id;
        this.title = title;
        this.content = content;
        this.author = author;
        this.publishTime = publishTime;
        this.modifyTime = modifyTime;
        this.board = board;
    }

    @Override
    public String toString() {//重写toString方法
        return "Article{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", author=" + author +
                ", publishTime=" + publishTime +
                ", modifyTime=" + modifyTime +
                ", board=" + board +
                '}';
    }

    public int getId() {//添加get和set接口
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

    public Date getPublishTime() {
        return publishTime;
    }

    public void setPublishTime(Date publishTime) {
        this.publishTime = publishTime;
    }

    public Date getModifyTime() {
        return modifyTime;
    }

    public void setModifyTime(Date modifyTime) {
        this.modifyTime = modifyTime;
    }

    public Board getBoard() {
        return board;
    }

    public void setBoard(Board board) {
        this.board = board;
    }
}

2--单例模式：不允许创建对象，只能使用管理员已经创建好的一个对象（只有一个对象）

（1）饿汉式单例模式：不管用户用不用这个对象，提前已经创建好。(浪费内

存空间）

1--私有化类的构造函数

2--创建一个私有静态对象（在类中）

3--创建一个public方法，返回已经创建的私有静态对象。

package Test;
public class Test39 { //单例模式练习(饿汉式单例模式）
    private static Test39 test39 = new Test39(); //在类里面创建一个私有的对象属性
    private Test39(){ //私有化构造函数，不允许外界创建对象
    }
    public static Test39 test(){ //给使用者提供创建好的对象
        return test39 ;
    }
}

（2）懒汉式单例模式：只有用户访问时才会创建对象。

1--私有化类的构造函数

2--创建一个私有静态对象，并使其内存值为空

3--创建public方法时，判断对象是否为空，如果是，则创建并返回这个

对象，如果不是，则直接返回这个对象。

package Test;
public class Test41 { //懒汉式单例模式
    private Test41(){
    }
    private static Test41 test41 = null ;
    public static Test41 test(){
        if(test41 == null) {
            test41 = new Test41();
        }
        return test41 ;
    }
}