java类的定义方式和实例化、this引用、对象的构造及其初始化、封装特性、static修饰成员变量、static修饰成员方法

java类的定义方式和实例化

类的定义和使用

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

在Java中定义类需要用到class关键字具体如下

// 创建类
class ClassName{  field;//成员变量method;//成员方法      
}

具体在实践中用类描述对象，并创建对象可以简单表示如下

public class Date {public int year;public int month;public int day;public void print(){System.out.println("year:"+this.year+" month:"+this.month+" day:"+this.day);}public static void main(String[] args) {Date day1=new Date();//这里用类创建实例就是通过newday1.print();使用成员方法就是类(新建类名.）}
}

类的注意事项

类名注意采用大驼峰定义
成员前写法统一为public
此处写的方法不带 static 关键字
new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.

this引用

this引用指向(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。后面构造里面的参数都要习惯加上this，一般如下

public class Date {public int year;public int month;public int day;public void setDay(int year, int month, int day){this.year = year;this.month = month;this.day = day;}}public void printDate(){System.out.println(this.year + "/" + this.month + "/" + this.day);}

this引用的注意事项

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
this只能在"成员方法"中使用
在"成员方法"中，this只能引用当前对象，不能再引用其他对象对象的构造及初始化

对象的构造及初始化

在java内部定义一个局部变量，如果不初始化会编译失败，但是在定义一个类之后怎么初始化就要用到构造了，构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次

public class Date {public int year;public int month;public int day;// 构造方法：// 名字与类名相同，没有返回值类型，设置为void也不行// 一般情况下使用public修饰// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次public Date(int year, int month, int day){this.year = year;this.month = month;this.day = day;System.out.println("Date(int,int,int)方法被调用了");}public void printDate(){System.out.println(year + "-" + month + "-" + day);}public static void main(String[] args) {// 此处创建了一个Date类型的对象，并没有显式调用构造方法Date d = new Date(2021,6,9);   // 输出Date(int,int,int)方法被调用了d.printDate();    // 2021-6-9}}

构造方法的注意事项

名字必须与类名相同
没有返回值类型，设置为void也不行
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
构造方法可以重载，无参，选择参数等等（ideal快捷generate->constructor->选择参数）

三种初始化方式

构造不传参，默认初始化
构造传参，自定义初始化
直接在函数里设置，就地初始化

三种方法如下：

public class Date {public int year;public int month;public int day;public Date() {
//        this.year = 2022;
//        this.month = 2022;
//        this.day = 2022;//   this(2,2,2);System.out.println("不带参数的的构造方法");//1}public Date(int year, int month, int day) {this.year = year;this.month = month;this.day = day;System.out.println("带参数的的构造方法");//2}public void print(){System.out.println("year:"+this.year+" month:"+this.month+" day:"+this.day);//必须加this}public static void main(String[] args) {Date day1=new Date();//默认初始化day1.print();Date day2=new Date(2000,2000,2000);//直接传参day2.print();Date day3=new Date();//直接赋值day3.year=1;//3day3.month=1;day3.day=1;day3.print();}
}

封装

简单点说封装就是对于一个电脑主机，用户只需要知道有个开关和usb接口就行了，不需要了解其内部构造，所以封装就是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装里面需要认识的访问限定符有public、default、private

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

这里着重讲解使用private：

public class Person {private String name;private int age;public Person(String name,int age){this.name=name;this.age=age;}public String getName(){return name;}public void setName(String name){this.name=name;}public int getAge(){return age;}public void SetAge(int age){this.age=age;}
}

上面例子中，name和age被声明为private，只能在Person类中被访问，在其他类中不能被访问，通过定义个getName和getAge方法，提供对name和age的访问，通过setName和setAge方法，提供对name和age的修改，这种方式实现了封装的效果，确保了隐私性的同时也能确保name和age只能通过方法进行访问和修改，设置getter和setter的快捷键（鼠标右键，Generate，选择Getter and Setter）

包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。

private修饰符的应用

导入包中的类

java 中已经提供了很多现成的类供我们使用，例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date 类

public class Test {public static void main(String[] args) {java.util.Date date = new java.util.Date();// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}

这种写法比较麻烦，直接用import语句导入包

import java.util.Date;//导包public class Test {public static void main(String[] args) {Date date = new Date();// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}

如果在导包里加上通配符 * ，就可以使用java.util中包括Date在内的其他类，用到谁就会导入谁

import java.util.*;

可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class Test {public static void main(String[] args) {double x = 30;double y = 40;//未使用import static使用方法需要加上包名// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));// 静态导入的方式写起来更方便一些.double result = sqrt(pow(x, 2) + pow(y, 2));System.out.println(result);}
}

static成员

static修饰成员变量，static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

需要注意的是静态变量属于类，而不是对象，常用于实现全局变量，但静态变量不是全局变量

static修饰成员变量

static 修饰的成员变量，称为静态成员变量 ，静态成员变量最大的特性： 不属于某个具体的对象，是所有对象所共 享的，会同时访问修改。

public class Student{public String name;public String gender;public int age;public double score;public static String classRoom = "Bit306";// ...结构体public static void main(String[] args) {// 静态成员变量可以直接通过类名访问System.out.println(Student.classRoom);//直接-》类名.静态变量Student s1 = new Student("Li leilei", "男", 18, 3.8);Student s2 = new Student("Han MeiMei", "女", 19, 4.0);Student s3 = new Student("Jim", "男", 18, 2.6);// 也可以通过对象访问：但是classRoom是三个对象共享的System.out.println(s1.classRoom);//新建对象.静态变量System.out.println(s2.classRoom);System.out.println(s3.classRoom);}
}

static修饰成员变量方法

Java 中，被 static 修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的 。静态成员一般是通过静态方法（静态方法只能访问静态变量）来访问的。

public class Student{private String name;private String gender;private int age;private double score;private static String classRoom = "Bit306";// ...public static String getClassRoom(){//静态方法，返回classroom值return classRoom;}
}public class TestStudent {public static void main(String[] args) {System.out.println(Student.getClassRoom());}
}