介绍
面向对象三大特征：封装、继承、多态。
类里面能写哪些东西：
public class 类名{
1、成员变量（代表属性，一般是名词）
2、成员方法（代表行为，一般是动词）
3、构造器
4、代码块
5、内部类
}
通过类得到对象：
类名 对象名 = new 类名();
使用对象：
对象名.成员变量; // 访问属性
对象名.方法名; // 访问行为
定义一个类：
public class Phone {
// 属性（成员变量）
String brand;
double price;
// 行为（方法）
public void call() {
System.out.println("手机在打电话");
}
public void playGame() {
System.out.println("手机在玩游戏");
}
}
使用这个类：
public class PhoneTest {
public static void main(String[] args) {
// 创建手机对象
Phone p = new Phone();
// 给手机赋值
p.brand = "华为";
p.price = 6999.9;
// 获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);
// 调用手机的方法
p.call();
p.playGame();
Phone p2 = new Phone();
p2.brand = "小米";
p2.price = 1999.9;
System.out.println(p2.brand);
System.out.println(p2.price);
p2.call();
p2.playGame();
}
}
执行结果：
华为
6999.9
手机在打电话
手机在玩游戏
小米
1999.9
手机在打电话
手机在玩游戏
用来描述某一个事物的类称为 Javabean 类，在 Javabean 类中，是不写 main() 方法的。
带 main() 方法的类，称为测试类。
可以在测试类中创建 Javabean 类的对象并赋值调用。
类名采用大驼峰命名规则。
一个 Java 源文件可以写多个类，但是只能有一个 public 类，且 public 类的类名必须和文件名相同。实际开发中，一般一个源文件只写一个类。
public是一个访问修饰符（access modifier），访问修饰符用于控制程序的其他部分对这段代码的访问级别。
成员变量的完整定义格式为：
修饰符 数据类型 变量名称 = 初始值;
但是一般都不写初始值，因为都有默认值。
默认值：
基本数据类型：
-
byte，short，int，long：0
-
float，double：0.0
-
char：空格
-
boolean：false
引用类型：
- String，类，接口，数组：null
程序示例：
Javabean 类：
public class Default {
byte b;
short s;
int i;
long L;
char c;
boolean boo;
float f;
double d;
String st;
}
测试类：
public class DefaultTest {
public static void main(String[] args) {
Default test = new Default(); // 如果此处写 Default test; 则会报错 java: 可能尚未初始化变量test
System.out.println(test.b);
System.out.println(test.s);
System.out.println(test.i);
System.out.println(test.L);
System.out.println(test.c);
System.out.println(test.boo);
System.out.println(test.f);
System.out.println(test.d);
System.out.println(test.st);
}
}
执行结果：
0
0
0
0
false
0.0
0.0
null
private 是一个修饰符，可以修饰成员，例如成员变量和成员方法等，用 private 修饰的成员，只能在本类中访问。
public 也是一个修饰符，也可以修饰成员，例如成员变量和成员方法等，用 public 修饰的成员，可以在所有的类中访问。
程序示例：
Javabean 类：
public class Girlfriend {
String name;
String sex;
private int age;
public void setAge(int a) {
if (a < 18 || a > 50)
System.out.println("非法数据。");
else age = a;
}
public int getAge() {
return age;
}
}
测试类：
public class GirlfriendTest {
public static void main(String[] args) {
Girlfriend g1 = new Girlfriend();
g1.sex = "女";
g1.name = "小团团";
g1.setAge(20);
System.out.println(g1.getAge());
System.out.println(g1.sex);
System.out.println(g1.name);
}
}
执行结果：
20
女
小团团
用 public 或 private 修饰成员变量时不影响它的默认值。
private 可以防止给成员变量一个不恰当的值。
程序示例：
Javabean 类：
public class GF {
// 成员变量
private int age;
private String name;
private String gender;
// getter 和 setter
public void setAge(int age) {
if (age < 18 || age > 30) {
System.out.println("年龄不合适");
} else {
this.age = age;
}
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getGender() {
return gender;
}
// 成员方法
public void playGame() {
System.out.println("GF is playing game.");
}
public void eat() {
System.out.println("GF is eating.");
}
}
测试类：
public class GFtest {
public static void main(String[] args) {
GF fg = new GF();
fg.setName("Hello");
fg.setAge(20);
fg.setGender("nv");
fg.eat();
fg.playGame();
System.out.println(fg.getAge());
System.out.println(fg.getGender());
System.out.println(fg.getName());
}
}
执行结果：
GF is eating.
GF is playing game.
20
nv
Hello
定义在方法里面的变量叫做局部变量（包括定义在方法头的形参变量），定义在方法外面类里面的变量叫做成员变量。遵循就近原则，如果局部变量和成员变量同名，则在方法内局部变量覆盖成员变量。如果不想覆盖，即在方法中使用同名的成员变量，需要在成员变量前面加关键字 this。
this 的本质：代表方法调用者的地址。
程序示例 1：
Javabean 类：
public class Girlfriend {
private int age; // 成员变量
public int getAge() {
int age = 10; // 局部变量
return age; // 返回局部变量
}
public int getAge1() {
int age = 10; // 局部变量
return this.age; // 返回成员变量
}
}
测试类：
public class GirlfriendTest {
public static void main(String[] args) {
Girlfriend g1 = new Girlfriend();
System.out.println(g1.getAge()); // 10
System.out.println(g1.getAge1()); // 0，0 是默认值
}
}
程序示例 2：
Javabean 类：
public class Girlfriend {
private String name;
private int age;
public void setName(String name) {
name = name;
}
public void setName1(String name) {
this.name = name;
}
public void setAge(int a) {
age = a;
}
public String getName() {
String name = "小团团";
return name;
}
public String getName1() {
String name = "小张";
return this.name;
}
public int getAge() {
int age = 10;
return age;
}
}
测试类：
public class GirlfriendTest {
public static void main(String[] args) {
Girlfriend g1 = new Girlfriend();
g1.setName("小明");
g1.setName1("小李");
g1.setAge(20);
System.out.println(g1.getAge()); // 10
System.out.println(g1.getName()); // 小团团
System.out.println(g1.getName1()); // 小李
}
}
如果不发生成员变量和局部变量同名的情况，this 写不写都一样。
程序示例：
Javabean 类：
public class Girlfriend {
private int age;
public int getAge() {
return age;
}
public int getAge1() {
return this.age;
}
}
测试类：
public class GirlfriendTest {
public static void main(String[] args) {
Girlfriend g1 = new Girlfriend();
System.out.println(g1.getAge()); // 0
System.out.println(g1.getAge1()); // 0
}
}
构造方法
构造方法也叫构造器或构造函数。
作用：在创建对象时，给成员变量进行初始化（即赋值）。
构造方法的格式：
public class Student {
// 构造方法
修饰符 类名(参数) {
方法体;
}
}
注意：
-
方法名必须和类名完全相同。
-
没有返回值类型，连 void 也不能有。
-
没有返回值，不能由 return 语句带回结果数据，即使是
return;也不能有。
使用空参构造方法时，成员变量被初始化为默认值。空参构造方法的方法体一般都是空着，什么都不写。
可以自定义带参构造方法。在方法体内，可以给成员变量赋值。
构造方法在创建对象时由虚拟机调用，不能手动调用构造方法。
每创建一次对象，就会调用一次构造方法。
如果没有自定义的构造方法，那么虚拟机会自动添加一个空参构造方法。
如果自定义了有参构造，那么虚拟机将不再提供默认的无参构造，在创建对象时，将不能再使用无参构造，如果还需要使用无参构造，则需要我们自己手动书写无参构造。
因此，建议如果写了自定义的有参构造，那么不管是否会用到无参构造，都再手动书写一个无参构造。
带参构造和无参构造是构造方法的重载。
带参构造一定是带全部参数.
如果在 Javabean 类中，定义的类只有有参构造，没有无参构造，在测试类中，定义类的对象时，不传递参数，想要调用无参构造，这时会报错，因为在 Javabean 类中，已经没有无参构造了，如果还需要无参构造，就需要自己去写无参构造了。
程序示例：
Javabean 类：
public class Girlfriend {
private int age;
private String name;
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public String getname() {
return name;
}
// 空参构造，虚拟机自动添加的构造方法就和这个长得一样。
public Girlfriend() {
}
// 带参构造
public Girlfriend(String name, int age) {
this.name = name;
this.age = age;
}
}
测试类：
public class GirlfriendTest {
public static void main(String[] args) {
Girlfriend g1 = new Girlfriend();
System.out.println(g1.getAge()); // 0
System.out.println(g1.getname()); // null
Girlfriend g2 = new Girlfriend("小张", 23);
System.out.println(g2.getAge()); // 23
System.out.println(g2.getname()); // 小张
g2.setAge(25); // 进行修改
g2.setName("小王");
System.out.println(g2.getAge()); // 25
System.out.println(g2.getname()); // 小王
}
}
标准的 Javabean 类
类名采用大驼峰。
所有成员变量都用 private 修饰。
提供至少两个构造方法：无参构造方法和带全部参数的构造方法。
成员方法：提供对应到每一个成员变量的 setXXX() / getXXX()。如果有其他行为，也需要写上。
快捷键：alt + insert 或者 alt + fn + insert
插件 PTG 可以 1 秒生成标准 Javabean，快捷键：ctrl + shift + ,