类是具有一定共性事物的集合,有两部分组成:
- 成员变量:描述状态信息
- 成员方法:描述能够做什么
类定义和使用
定义一个类注意:
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私有
使用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();
}
}