封装 2019-03-09

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)匿名对象,就是一块没有栈内存空间指向的内存地址,只能使用一次,之后等待垃圾回收机制回收

你可能感兴趣的:(封装 2019-03-09)