1 封装的初步概念（重点）
封装属于面向对象的第一大特性，对于封装性的讲解以代码的方式大家观察以下为什么要使用封装？
范例：观察没有封装操作的情况
class Person
{
private String name ; //定义姓名 使用了private访问修饰在类的外部不能被访问
private int age ; //定义年龄
public void tell(){ //定义类的方法
System.out.println("姓名"+name+",年龄"+age);
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person(); //声明并实例化对象
per.name="张三";
per.age=-30;
per.tell();
}
}
以上的程序，由于在没有封装的情况下数据安全性非常不好，数据可以被任意的修改，为了不让数据被用户任意的修改，把属性访问权限修改为private (只能在本类中使用)，外部不可进行调用赋值
接下来的问题，如何在外部使用被private修饰的属性？
对于以上的问题，使用setter以及getter方法来进行解决
class Person
{
private String name ; //定义姓名 使用了private访问修饰在类的外部不能被访问
private int age ; //定义年龄
//setter 方法
public void setName(String n){
name=n;
}
public void setAge(int a){
if(a<18){
a=18;
}
age=a;
}
//getter方法
public String getName(){
return name;
}
public int getAge(){
return age;
}
public void tell(){ //定义类的方法
System.out.println("姓名"+name+",年龄"+age);
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person(); //声明并实例化对象
per.setName("张三");
per.setAge(16);
System.out.println(per.getName()); //单独输出per对象的属性名称
System.out.println(per.getAge()); //输出年龄
per.tell();
}
}
以上的Person类的属性使用private关键字进行了封装，只能在本类中对private关键的属性进行访问,但是在外部通过对象调用属性的时候会出现语法错误，不允许访问 虽然此时属性是安全了，但是这些属性依然还需要被外部访问. 就java开发标准来说，必须使用setter以及getter方法来进行private修饰的属性的访问
setter以及getter方法的命名规则如下
public void setName(String n){}
Public String getName(){return name}
以后在开发编写一个类的时候，属性都需要使用private进行修饰，而为对应的属性编写setter以及getter方法
2 构造方法（重点）
在讲解构造方法之前，首先观察如下的格式
类名称 对象名称 =new 类名称();
对于以上的格式，其功能声明并且实例化一个类,下面就针对以上格式对每一个关键字进行讲解
类名称 ：要定义对象的数据类型
对象名称： 对类中的属性或方法进行调用变量名称
new: 开辟内存空间
类名称(): 表示实例化对象，按照道理来讲 加上（）的都是方法,即这个方法是与类名称保持一致的方法，构造方法 .这个方法与普通的方法不太一样, 构造方法是在实例化对象时使用的，而普通的方法使在实例化对象之后使用的
在java中构造方法存在相应的规则：
1 构造方法的名称与类名称保持一致
2 构造方法不允许存在返回值类型
3 实例化对象的时候，一定要有构造方法的存在（类中会提供一个默认 无参构造方法），如果显示的定义了构造方法则默认的构造方法则失去作用
范例：使用构造方法
class Person
{
private String name ; //定义姓名 使用了private访问修饰在类的外部不能被访问
private int age ; //定义年龄
public Person(){
name="张三";
age=20;
}
public Person(String n,int a){
name=n;
age=a;
}
public void tell(){ //定义类的普通方法
System.out.println("姓名"+name+",年龄"+age);
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person("李四",50); //声明并实例化对象
per.tell();
}
}
构造方法作用主要目的就是为对象赋予初始变量内容，在实例化对象的时候进行调用
3 构造方法的重载（掌握）
对于构造方法的重载，实际上在类中可以定义多个构造方法（参数的类型与个数不同）
范例：在类中定义多个构造方法
class Person
{
private String name ; //定义姓名 使用了private访问修饰在类的外部不能被访问
private int age ; //定义年龄
private String sex; //定义性别
public Person(){ //无参数的构造方法
}
public Person(String n,int a){ //定义两个参数的构造方法
name=n ;
age=a;
}
public Person(String n ,int a,String s){ //定义三个参数的构造方法
name=n;
age=a;
sex=s;
}
public void tell(){ //定义类的普通方法
System.out.println("姓名"+name+",年龄"+age);
}
}
对于以上的代码，在实际的实例化对象的时候只要给定相应的参数，则就可以调用相应的构造方法
范例：构造方法的调用
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person("边继斌",98,"??");
per.tell();
}
}
对于构造方法来说，也是可以直接在构造方法中调用普通的方法，在进行初始化赋值的时候也可以在构造方法使用setter方法进行验证
4 匿名对象(重点)
如果一个对象没有栈没存空间中进行指向，这个对象就是匿名对象,可以把匿名对象理解为只能使用一次的对象
范例：定义一个匿名对象
public class TestDemo02
{
public static void main(String[]args){
new Person("张三",20).tell(); //通过匿名对象来调用方法
new Person("zhang",30).tell();
}
}
以上的程序，通过匿名对象调用了类中的方法,由于匿名对象没有栈空间引用,使用一次之后会变为垃圾空间等待GC被回收
5 简单java类的编写（掌握）
简单java类是现在比较重要的开发模型,比如以后常见的技术框架，spring status2 mybtis 这些框架技术都是围绕着简单java进行开发的
如果现在定义的一个类指包含基本的属性,则必须为属性设置setter以及getter方法,这样的类就可以理解为简单java类，简单java类的开发原则如下：
1 类名称必须明确的表示出类的定义例如： 人类 Person 部门Dept
2 类中所有的属性必须使用private 关键字进行封装
3 类中所有的属性都必须定义相应的setter以及getter方法
4 类中可以提供构造方法，为属性初始化，不管编写了多少个构造方法，但是必须为类提供一个无参的构造方法
范例：通过一个简单的案例，编写一个简单的java类,本次编写一个雇员类
class Emp
{
private int empno; //雇员编号
private String ename; //雇员姓名
private String job; //雇员职位
private double sal ; //基本工资
private double comm ;//奖金
//以上为基本属性 使用private进行封装
//编写构造方法
public Emp(){} //无参的构造方法
public Emp(int eno,String ena,String j,double s,double c){ //有参数的构造方法
empno=eno;
ename=ena;
job=j;
sal=s;
comm=c;
}
//雇员完整信息的输出方法
public String getInfo(){
return "雇员信息"+"\n"+
"\t 编号"+empno+"\n"+
"\t 姓名"+ename+"\n"+
"\t 职位"+job+"\n"+
"\t 工资"+sal+"\n"+
"\t 奖金"+comm;
}
//编写setter方法
public void setEmpno(int eno){
empno=eno;
}
public void setEname(String ena){
ename=ena;
}
public void setJob(String j){
job=j;
}
public void setSal(double s){
sal=s;
}
public void setComm(double c){
comm=c;
}
//编写getter方法
public String getEname(){
return ename;
}
public int getEmpno(){
return empno;
}
public String getJob(){
return job;
}
public double getSal(){
return sal;
}
public double getComm(){
return comm;
}
}
public class TestDemo02
{
public static void main(String[]args){
Emp emp=new Emp(10,"斌斌","洗厕所",10.98,3);
System.out.println(emp.getInfo());
}
}
练习：编写三个类似的简单java类
总结
1 封装的基本概念主要的目的就是保证数据的安全性，使用到的关键为private ,只能本类中所访问，对private修饰的属性，需要为其编写对应setter以及getter方法
2 构造方法，为对象进行初始化的时候赋值使用的，构造方法的特点如下：
1）方法名称与类名称一致，并且没有返回值
2）类中会提供一个默认的无参的什么都不做的构造方法
3）当用户显示定义了构造方法之后默认提供的构造方法则不会生成，所以用户需要显示的定义一个无参的构造方法
4）构造方法支持方法的重载
5）匿名对象，就是一块没有栈内存空间指向的内存地址，只能使用一次，之后等待垃圾回收机制回收
