1.1 封装
1.1.1 封装体现
1.方法就是一个封装体。
2.关键字private也是一种封装。
1.1.2 封装的含义
封装:把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的成员方法才能对数据进行操作。
1.1.3 封装的好处
1 提高了代码的复用性。
2 隐藏了实现细节，还要对外提供可以访问的方式，便于调用者的使用。
3 提高了安全性。
1.1.4 private关键字
private只能修饰成员变量，不能修饰局部变量。被private修饰的成员只能在本类中使用，对于非本类的提供公共的访问方式；这种方式被称为方法。此做法的目的（1）为了保护数据；（2）可以筛选不合理的值；比如年龄设置为int，负数也可以被输出；有了方法就可以增加约束条件。
定义方法设置值必须以set开头，取值必须以get开头。
public class Person {
//成员变量
private String name;
private int age;
//设置值
public void setName(String a) {
name=a;
}
public void setAge(int b) {
//给年龄增加条件
if(b>0&&b<100){
age=b;
}else {
System.out.println("输入不合理");
}
}
public static void main(String[] args) {
Person p=new Person(); //创建对象
p.setName("张三"); //调用set方法设置值
p.setAge(-20); //传入不合理的值
p.add(); //调用成员方法
}
//获取值
public String getName() {
return name;
}
public int getAge() {
return age;
}
//成员方法
public void add() {
System.out.println("我叫"+name+",今年"+age+"岁了");
}
结果：
输入不合理
我叫张三,今年0岁了
1.1.5 private关键字定义
对于String、int类型使用的是常规的getXxx、setXxx方法，但是对于boolean类型的数据setXxx方法不变，但是获取方式有所不同。采用的是isXxx方式。
public class Person {
//定义成员变量
private String name;
private int age;
private boolean male; //是否为爷们
//提供getXXX、setXXX方法
public void setName(String a) {
name=a;
}
public String getName() {
return name;
}
public void setAge(int b) {
if(b>0&&b<100) {
age=b;
}else {
System.out.println("年龄输入不合理");
}
}
public int getAge() {
return age;
}
public void setMale(boolean c) {
male=c;
}
public boolean isMale() {
return male;
}
}public class PersonDemo {
public static void main(String[] args) {
Person p=new Person();
p.setName("张三");
p.setAge(20);
p.setMale(true);
System.out.println("姓名："+p.getName());
System.out.println("年龄："+p.getAge());
System.out.println("是不是爷们儿："+p.isMale());
}
}结果：
姓名：张三
年龄：20
是不是爷们儿：true
1.1.6 this关键字
this关键字主要用来区别成员变量和局部变量重名的问题。当成员变量和局部变量重名时，需要在方法中的成员变量前面加this.
public class Student {
private String name;
private int age;
public void SetName(String name) {
this.name=name;
}
public String getName() {
return name;
}
public void SetAge(int age) {
this.age=age;
}
public int age() {
return age;
}
public void add() {
String name="哈哈";
int age=18;
System.out.println("名字是"+this.name+"年龄"+this.age+"岁");
//不加this.结果是哈哈，18；加了this.结果是呵呵，20
}
public static void main(String[] args) {
Student s=new Student();
s.SetName("呵呵");
s.SetAge(20);
s.add();
}
1.1.7 构造方法
构造方法是专门用来创建对象的方法，当我们用new来创建对象的时候，其实就是在调用构造方法。
格式：
public 类名称(参数类型 参数名称){
方法体；
}
public class Student {
public Student() { //定义一个构造方法
System.out.print("构造方法在执行！");
}
}
public class StudentDemo {
public static void main(String[] args) {
Student s=new Student();
}
}
上面程序可以看到用new在创建对象的时候，就是在调用构造方法。
构造方法解决的问题就是在创建对象的时候就明确对象的属性值。不需要再使用get/set方法去手动赋值。
public class Student {
private String name;
private int age;
public Student(String name,int age) {
this.name=name;
this.age=age;
}
public void show() {
System.out.println("名字是"+name+"，今年"+age+"岁了");
}
}
public class StudentDemo {
public static void main(String[] args) {
Student s=new Student("张三",20);
s.show();
}
}
构造方法注意事项： （1）构造方法的名称必须和所在类的类名完全相同 （2）构造方法不能写任何返回值类型，连void都不能写，写了就是普通方法了。 （3）不能在方法体中写return （4）在创建完对象之后，构造方法就执行了一次且终生执行一次。 （5）每个类都具有无参构造方法，不写也有（没有参数，方法体什么也不做），手写了构造方法之后，编译器不会自动添加构造方法。（6）构造方法也可以像普通方法一样进行重载，在创建对象时，可以通过调用不同的构造方法为不同的属性赋值（7）在有了构造方法对对象的属性进行初始化，我们依旧需要getXxx/setXxx方法；因为对象在创建后需要修改和访问相应的属性值时，在这时只能通过getXxx/setXxx方法去操作。
1 public class Student {
2 private String name;
3 private int age;
4 public Student() {
5 System.out.println("无参构造");
6 }
7 public Student(String name) {
8 this.name=name;
9 }
10 public Student(String name,int age) {
11 this.name=name;
12 this.age=age;
13 }
14 //提供getXxx/setXxx方法
15 public String getName() {
16 return name;
17 }
18 public void setName(String name) {
19 this.name = name;
20 }
21 public int getAge() {
22 return age;
23 }
24 public void setAge(int age) {
25 this.age = age;
26 }
27 //成员方法
28 public void show() {
29 System.out.println("名字是"+name+"今年"+age+"岁了");
30 }
31
32 public class StudentDemo {
33
34 public static void main(String[] args) {
35 Student s=new Student();
36 s.show(); //调用无参构造
37 Student s1=new Student("张三");
38 s1.show(); //调用有一个参数的构造方法
39 Student s2=new Student("王五",20);
40 s2.show();//调用有二个参数的构造方法
41 System.out.println("=====================");
42 //修改age的属性值，依旧需要在Student类中提供getXxx/setXxx方法
43 s2.setAge(21);
44 s2.show();
45 }
46 }结果：
无参构造
名字是null今年0岁了
名字是张三今年0岁了
名字是王五今年20岁了
=====================
名字是王五今年21岁了
构造方法与普通方法的区别： 构造方法在创建对象后就执行了，而且只执行一次。 一般方法是在对象创建后，需要使用时才被对象调用，且可以多次调用。
扩展：this在构造方法之中的调用
在程序中无法像调用其他方法一样去调用构造方法；但可以在一个构造方法中去调用另一个构造方法。
1 public class Person {
2 //定义成员变量
3 private String name;
4 private int age;
5 //无参构造
6 public Person() {
7 this("张三",20); //在无参构造中去调用有参构造
8 }
9 //有参构造
10 public Person(String name,int age) {
11 this.name=name;
12 this.age=age;
13 }
14 public void show() {
15 System.out.println("我叫"+name+",今年"+age+"岁了");
16 }
17 }
18
19 public class PersonDemo {
20
21 public static void main(String[] args) {
22 Person p=new Person(); //调用无参构造
23 p.show();
24 }
25 }结果：
我叫张三,今年20岁了
注意： （1）只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。 （2）在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。 （3）不能在一个类的两个构造方法中使用this互相调用。
1.1.8 定义一个标准类
通常来说一个标准的类要有四个组成部分：
（1）所有的成员变量都需要用private去修饰
（2）为每一个成员变量编写一对getter/setter方法
（3）编写一个无参数的构造方法
（4）编写一个全参数的构造方法
这样的一个标准类也叫做Java Bean。