目录
一、类的定义
1、在java中定义类需要用到class关键字
class ClassName{
filed; //成员变量（属性）
method; //成员方法
}2、类的使用（实例化）
定义类，就相当于在计算机中定义了一种新的类型，用定义的类类型创建对象的过程，称为类的实例化。
//定义了一个狗类
class PetDog {
public String name;//名字
public String color;//颜色
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}
}
public class Main{
public static void main(String[] args) {
PetDog dogh = new PetDog(); //通过new实例化对象
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();
}
二、this引用
java编译器给每个“成员方法”增加了一个隐藏的引用类型参数（this），该引用参数指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中所有成员变量的操作，都是通过该引用去访问。（this引用的是调用成员方法的对象）
对于以下代码：
public class Date {
public int year;
public int month;
public int day;
public void setDay(int y, int m, int d) {
year = y;
month = m;
day = d;
}
public void printDate() {
System.out.println(year + "/" + month + "/" + day);
}
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Date d1 = new Date();
Date d2 = new Date();
Date d3 = new Date();
// 对d1，d2，d3的日期设置
d1.setDay(2020, 9, 15);
d2.setDay(2020, 9, 16);
d3.setDay(2020, 9, 17);
// 打印日期中的内容
d1.printDate();
d2.printDate();
d3.printDate();
}
}（1）形参名与成员变量名相同
根据局部变量优先原则，方法中的year都为方法的参数year，次数编译无法通过，需要通过this来调用类中的成员变量。
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}（2）当三个对象都在调用方法setDate和printDate时，函数不能确定打印的是那个对象的数据，此时需要this来确定打印对象。
public void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}三、构造方法及对象的初始化
1、构造方法
是一种特殊的成员方法。名字必须与类名相同，创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
【特性】
- 名字必须与类名相同。
- 没有返回值类型，设置为void也不行。
- 构造方法至少一个，可以是多个。
- 创建对象时编译器自动调用，并且在对象的生命周期中只调用一次。
- 构造方法可以重载。（可以根据自己的需求提供不同参数的构造方法）
public class Date {
public int year;
public int month;
public int day;
// 无参构造方法
public Date() {
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}- 没有定义构造方法时，编译器会生成一个默认的构造方法，生成的构造方法一定是无参的。一旦用户定义了构造方法，编译器便不再生成。
- 可以在一个构造方法中使用this调用另一个构造方法。
public class Date {
public int year;
public int month;
public int day;
//不带参数的构造方法
public Date(){
this(1900, 1, 1);
System.out.println(year);
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}- 绝大多数情况下使用public修饰，特殊情境下会被private修饰
2、对象的初始化
（1）默认初始化
局部变量在使用时必须要初始化，而成员变量不用。因为new会调用构造方法，给对象中各个成员赋值。
（2）就地初始化
在声明成员变量时，直接给出初始值。
四、封装
【访问限定符】
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用。java中提供了四种访问权限符：
| 范围 | private | default | protected | public |
| 同一个包的同一个类 | √ | √ | √ | √ |
| 同一个包的不同类 | √ | √ | √ | |
| 不同包中的子类 | √ | √ | ||
| 不同包中的非子类 | √ |
对于private修饰的变量，我们可以通过get和set方法来获取和操作它。
（右键→Generate→GetterandSetter）即可
public class Computer {
private String cpu;// cpu
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
}【注】一般情况下，成员变量设置为private，成员方法设置为public
五、包
1、包的概念
软件包：为了更厚的管理类，把多个类收集在一起成为一组，称为包。
在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。
2、导入包中的类
使用import语句导入包。
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}对于以下情况：
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}两个包中都存在Date类，此时我们需要引用完整的类名，否则编译器不知道调用哪个包下的Date类。
3、自定义包
【新建包】右键src→新建→包
【新建类】右键包名→新建→类
4、常见的包
- Java.lang：系统常见基础类（String 、Object）编译器会自动导入
- java.lang.reflect：java反射程序包
- java.net：进行网络编程开发包
- java.sql：进行数据库开发的支持包
- java.util：java提供的工具程序包
- java.io：I/O编程开发包
六、static成员
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，不属于某个具体的对象，是所有的对象共享的。
静态的成员变量和成员方法都是不依赖于对象的
1、static修饰成员变量
2、静态成员方法
【静态成员方法特性】
- 不属于某个具体的对象，是类方法
- 通过 类名.静态方法名（……）方式调用
- 不能在静态方法中访问任何非静态成员变量（静态方法没有隐藏的this引用参数）
public static String getClassRoom(){
System.out.println(this);
return classRoom;
}
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
age += 1;
return classRoom;
}
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 ag- 静态方法中不能调用任何非静态方法，（非静态方法有this参数，在静态方法中调用时无法传递）
七、代码块
【注】代码块的执行顺序：
静态代码块（只执行一次）→实例代码块→构造方法
public class Student{
private String name; //实例成员变量
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
// 静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}1、普通代码块：定义在方法中的代码块
2、构造代码块：定义在类中的代码块。也称实例代码块，一般用于初始化实例成员变量
定义在类的内部，和构造方法同级。
3、静态代码块：使用static修饰的代码块。一般用于初始化静态成员变量
八、对象的打印
当类中有多个成员变量，我们需要打印对象中内容，此时应该重写toString方法。
（鼠标右击→Generate→toString()）即可
public class Person {
String name;
String gender;
int age;
public Person(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
@ Override
public String toString() {
return "[" + name + "," + gender + "," + age + "]";
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
} // 输出结果：[Jim,男,18] 九、内部类
在java中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。
1、实例内部类
定义在类中，未被static修饰的类
2、静态内部类
被static修饰的内部成员类
3、局部内部类
定义在外部类的方法中，这种内部类只能在其定义的位置使用，一般使用的非常少
