本文详细介绍了Java中类的定义、实例化过程，包括构造方法、成员变量、成员方法的使用，以及封装和静态成员的概念，帮助读者理解类的构造和基本操作方式。
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();//这里用类创建实例就是通过new
day1.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;//3
day3.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修饰成员变量
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修饰成员变量方法
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());
}
}静态成员变量特性
- 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
- 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
- 类变量存储在方法区当中
- 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
