- 类定义和使用
- 权限修饰符
- private私有
- this关键字
- 构造方法
- static静态
类是具有一定共性事物的集合，有两部分组成：
- 成员变量：描述状态信息
- 成员方法：描述能够做什么
定义一个类注意：
1.成员变量直接写在类当中，在方法外面
2.成员方法不要写static关键字
类使用：
1.导包，就是支出需要使用的类在什么位置，在一个文件夹里不需要导
2.创建对象：类名 对象名 = new 类名()
3.使用对象：对象名.成员变量；对象名.成员方法()
注意：成员变量没有赋值，则会有默认值
public class Demo01Class {
public static void main(String[] args) {
// 1.创建对象
Student stu = new Student();
// 使用成员变量
System.out.println(stu.name); // null
System.out.println(stu.age); // 0
//改变成员变量
stu.name = "小明";
stu.age = 8;
System.out.println(stu.name); // 小明
System.out.println(stu.age); // 8
//使用成员方法
stu.study();
stu.eat();
}
}
class Student {
String name;
int age;
public void study () {
System.out.println("学习");
}
public void eat () {
System.out.println("吃饭");
}
}
权限修饰符
四种权限修饰符：public > protected > default > private
访问控制如下
| 修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
|---|---|---|---|---|---|
| public | Y | Y | Y | Y | Y |
| protected | Y | Y | Y | Y/N | N |
| default | Y | Y | Y | N | N |
| private | Y | N | N | N | N |
使用private关键字修饰成员变量，则就成为了私有属性。私有属性在本类中仍然可以随意访问，但是超出本类范围就不能直接访问了。可以通过两个额外的成员方法读取（get）和设置（set）成员变量。
在定义设置私有属性的方法时，就可以对这个属性做校验和拦截，比如，年龄只能在0-200之间。
示例：
public class Demo00Person {
String name;
private int age;
public void show() {
System.out.println("我是" + name + "，年龄：" + age);
}
public int getAge() {
return age;
}
public void setAge(int num) {
if (num > 0 && num <200) {
age = num;
} else {
System.out.println("年龄不合理");
}
}
}
public class Demo02Private {
public static void main(String[] args) {
Demo00Person person = new Demo00Person();
person.show(); // 我是null，年龄：0
// 姓名可以直接赋值
person.name = "小明";
// age不能直接赋值，和获取，需要通过set和get方法
person.setAge(-1); // 年龄不合理
person.setAge(20);
person.show();
}
}
注意：
1.对于get方法，不能有参数，返回值必须和成员变量的类型对应
2.对于set方法，不能有返回值，参数类型必须和成员变量的类型对应
3.对于基本类型中的boolean值，get方法一定要写成isXxx形式，set方法不变
好处：阻止不合理和属性设置，提高数据安全性
this关键字当方法的局部变量和类的成员变量名字重合，根据就近原则，优先使用局部变量，如果想在方法里使用成员变量，就要使用this，代表对象本身。哪个对象调用，this就代表谁。
示例：
public class Demo00Person2 {
String name;
int age;
public void call(String name) {
// 成员变量有个name，方法的局部变量也有个name，那么下面加this的就是成员变量，不加的是局部变量
System.out.println(this.name + "打电话给" + name);
}
}
public class Demo03This {
public static void main(String[] args) {
Demo00Person2 person = new Demo00Person2();
person.name = "aa";
person.call("bb");
}
}
构造方法
即创建对象的方法，当使用new来创建对象时，就调用了构造方法。
1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样；
2.构造方法不要写返回值类型，也没有void
3.构造方法不能return一个具体的值
4.如果没有编写任何构造方法，编译器默认有个构造方法，没有参数和方法，什么也没做
5.一旦编写了至少一个构造方法，编译器不再提供构造方法
6.构造方法可以重载
示例：
public class Student2 {
private String name;
private int age;
public Student2() {
System.out.println("无参构造方法");
}
public Student2(String name, int age) {
System.out.println("有参构造方法");
this.name = name;
this.age = age;
}
}
public class Demo03Init {
public static void main(String[] args) {
Student2 stu1 = new Student2();
Student2 stu2 = new Student2("小明", 8);
}
}
static静态
使用static关键字，则修饰的内容不再属于对象自己，而属于类，所有本类的对象共享这一属性或方法。
1.静态属性
如下，定义一个学生类，共享一个班级。并定义一个学号计算器，每new一个对象，写好自动加1。
package base7_class;
public class Student3 {
private int id;
private String name;
private int age;
static String classRoom;
private static int idCount; // 计数器，每当创建一个对象，就idCount++
public Student3() {
this.id = ++idCount;
}
public Student3(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCount;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
}
package base7_class;
public class Demo05Static {
public static void main(String[] args) {
Student3 stu1 = new Student3("小明", 8);
System.out.println(stu1.getId()); // 1
stu1.classRoom = "01";
System.out.println(stu1.classRoom);
Student3 stu2 = new Student3("小明", 8);
System.out.println(stu2.getId()); // 2
System.out.println(stu1.classRoom); // 所有成员共享，与stu1相同
}
}
2.静态方法
被static修饰的方法称为静态方法，调用时不需要通过对象调用，可以通过类直接调用。
package base7_class;
public class Student4 {
public void method() {
System.out.println("成员方法");
}
public static void staticMethod() {
System.out.println("静态方法");
}
}
package base7_class;
public class Demo06StaticMethod {
public static void main(String[] args) {
Student4 student4 = new Student4();
student4.method();
// 访问静态方法
student4.staticMethod(); // 不推荐使用
Student4.staticMethod(); // 推荐使用
}
}
注意：
1.静态属性和方法推荐使用类直接调用。
2.静态不能直接访问非静态，因为在内存中先有的静态内容，再有的非静态内容
3.静态方法不能使用this
package base7_class;
public class Demo07StaticMethod {
int num;
static int staticNum;
public void method() {
System.out.println("成员方法");
// 成员方法可以访问成员变量
System.out.println(num);
// 成员方法可以访问静态变量
System.out.println(staticNum);
}
public static void staticMethod() {
System.out.println("静态方法");
// 成员方法可以访问静态变量
System.out.println(staticNum);
// 成员方法不可以访问成员变量
// System.out.println(num);
// 静态方法中不能使用this
// System.out.println(this); // 错误写法
}
}
3.静态代码块
使用static修饰的代码。静态代码块总是优先执行，且只在第一次使用类时执行唯一的一次。
package base7_class;
public class Student5 {
static {
System.out.println("静态代码执行");
}
public Student5() {
System.out.println("构造方法执行");
}
}
package base7_class;
public class Demo08StaticCode {
public static void main(String[] args) {
// 第一次new时，使用了类和构造方法，静态代码块和构造方法都执行，且静态代码先执行
Student5 student = new Student5();
// 第二次new对象，静态代码不再执行
Student5 student2 = new Student5();
}
}
