你的位置:首页 > Java教程

[Java教程]Java学习 (十)、面向对象编程(二)封装


面向对象三大特点:封装、继承、多态

封装概念

①   将东西包装在一起,然后以新的完整形式呈现出来:

将方法和字段一起包装到一个单元中,单元以类的形式实现;

②   信息隐藏,隐藏对象的实现细节,不让外部直接访问到;

③   将数据和方法包装进类中,加上具体实现的隐藏,共同被称作封装,其结果是一个同时带有特征和行为的数据类型;

④   定义类,定义其属性、方法的过程称为封装类;

 

信息隐藏式OOP最重要的功能之一,也是使用访问修饰符的原因;

信息隐藏的原因包括:

①   对模块的任何实现细节所作的更改不会影响使用该模块的代码;

②   防止用户意外修改数据;

③   是模块易于使用和维护;

 

访问修饰符

①   public:该类或非该类都均可访问;

②   private:只有该类可以访问;

③   protected:该类及其子类的成员可以访问,同一个包中的类也可以访问;

④   默认:同一包中的类可以访问;

 

属性封装的实现

①   修改属性的可见性来限制对属性的访问;

②   为每个属性创建一对赋值(setter)方法和取值(getter)方法,用于公开对这些属性的访问接口;

③   在setter和getter方法中,根据需要加入对属性操作的限制;

要点:除非必须公开底层实现细节,否则应该将所有属性指定为private加以封装;使用属性封装,通过增加数据访问限制,增强了类的可维护性;

 

封装方法的目的

①   隐藏方法实现细节(方法体),向外部提供公开接口(方法头),以供安全;

②   简化调用,方便修改维护;

③   根据需要,可以私有化方法以供类内部使用----帮助方法help;

 1 public class TeacherDemo 2 { 3   public static void main(String []agrs){ 4     Teacher t=new Teacher(); 5     //t.name="张三";//不能直接赋值 6     t.setName("张三"); 7     System.out.println(t.getName()); 8     t.setAge(10); 9     System.out.println(t.getAge());10   }11 }12 13 class Teacher14 {15   private String name;16   private int age;17   public void setName(String tname){18     name=tname;19   }20   public String getName(){21     return name;22   }23   public void setAge(int tage){24     if(tage<25)25     {26       System.out.println("年龄太小了");27       age=25;28     }29     else30     {31       age=tage;32     }33   }34   public int getAge(){35     return age;36   }37 }

View Code

 

类的构造方法的概念和作用

①   构造方法负责对象初始化工作,为对象的属性赋合适的初始值;

②   创建对象时,其类的构造方法确保在用户操作对象之前,系统保证初始化的进行;

构造方法的语法规则

①   构造方法名与类名相同

②   没有返回类型

③   方法实现主要为字段赋初值

构造方法的调用和特别:new操作符(返回新建实例的引用)

无参构造方法

 1 public class ConstructorDemo 2 { 3   public static void main(String []agrs){ 4     Person p=new Person();//实例化的时候是有初始值的int默认0,String默认null 5     p.setName("张三"); 6     p.setAge(10); 7     System.out.println(p.toString()); 8   } 9 }10 11 //当一个类没有显示声明一个构造方法时,系统会有一个默认的无参构造方法12 class Person13 {14   private String name;15   private int age;16   private String city;17   18   //默认的构造方法,实例化时候会调用,此处不写也可以,系统已默认写好19   public Person(){20     System.out.println("Person");21   }22   23 24   public void setCity(String pcity){25     city =pcity;26   }27   public String getCity(){28     return city;29   }30   31   public void setName(String pname){32     name=pname;33   }34   public String getName(){35     return name;36   }37   38   public void setAge(int page){39     age=page;40   }41   public int getAge(){42     return age;43   }44   45   public String toString()46   {47     return "名字:"+name+",今年"+age+"岁,家住"+city;48   }49 }

View Code

带参构造方法

 1 public class ConstructorDemo 2 { 3   public static void main(String []agrs){ 4     //带参调用,若不写参数会报错,因为Person中只有一个带参的构造方法 5     Person p=new Person("张三",10,"杭州"); 6     //1、在堆中开辟空间,给属性分配默认的初始值 7     //2、假设属性一开始就赋值了,就进行赋值工作 8     //3、调用构造方法对属性进行初始化 9     System.out.println(p.toString());10   }11 }12 13 class Person14 {15   private String name="李四";16   private int age;17   private String city;18   19   //带参数的构造方法20   public Person(String pname,int page,String pcity ){21     name=pname;22     age=page;23     city=pcity;24   }25   26   public void setCity(String pcity){27     city =pcity;28   }29   public String getCity(){30     return city;31   }32   33   public void setName(String pname){34     name=pname;35   }36   public String getName(){37     return name;38   }39   40   public void setAge(int page){41     age=page;42   }43   public int getAge(){44     return age;45   }46   47   public String toString()48   {49     return "名字:"+name+",今年"+age+"岁,家住"+city;50   }51 }

View Code

 

this关键字

特点:

①在类的方法中使用的this关键字代表的是调用此方法的对象的引用;

②this可以看作是一个变量,它的值是当前对象的引用;

③使用this可以处理方法中的成员变量和形参同名的问题;

④当方法内需要用到调用该方法的对象时,就可以用this;

⑤在类的构造方法中可以调用this([参数列表])来调用该类的指定构造方法。

 1 public class ConstructorDemo 2 { 3   public static void main(String []agrs){ 4     Person p=new Person("张三",10,"杭州"); 5     System.out.println(p.toString()); 6   } 7 } 8  9 10 class Person11 {12   private String name="李四";13   private int age;14   private String city;15   16   //构造方法17   public Person(){18     System.out.println("无参构造方法");19   }20   21   //带参数的构造方法22   public Person(String name,int age,String city ){23     24     this();//表示调用当前对象的无参构造方法,必须写在第一句25     26     //此处将形参名称写成age与属性名相同27     //age=age;//此处不会对属性重新赋值age=028     this.age=age;//此处对属性重新赋值age=10,this代表p  29     this.name=name;30     this.city=city;31     32   }33   34   public void setCity(String city){35     this.city=city;36   }37   public String getCity(){38     return city;39   }40   41   public void setName(String name){42     this.name=name;43   }44   public String getName(){45     return name;46   }47   48   public void setAge(int age){49     this.age=age;50   }51   public int getAge(){52     return age;53   }54   55   public String toString()56   {57     //默认前面都是有this的,可写可不写58     System.out.println(this.getAge());59     return "名字:"+this.name+",今年"+age+"岁,家住"+city;60   }61 }

View Code

 

static关键字

特点:

①用来修饰类的成员----修饰成员变量的称之为类变量(静态变量),修饰成员方法的称之为类方法(静态方法);

②当类被加载时就会被加载,优先于对象的存在;

③用来修饰语句块----称之为静态代码块。先于构造方法之前执行,只会执行一次,用来对静态成员做初始化;

④静态修饰的成员被所有的对象共享;

⑤调用的时候可以直接通过类名.成员来进行访问

static关键字注意事项

①   静态方法中只能访问外部的静态成员;

②   静态方法中不能出现this;

 

非静态

 1 public class StaticDemo 2 { 3   public static void main(String []agrs){ 4     Account acc1=new Account(); 5     acc1.number1++; 6     acc1.showNumber1(); 7     acc1.showNumber2(); 8      9     Account acc2=new Account();10     acc2.showNumber1();11     acc2.showNumber2();12   }13 }14 15 class Account16 {17   public int number1=1;18   public int number2=2;19   public void showNumber1()20   {21     System.out.println(number1);22   }23   public void showNumber2()24   {25     System.out.println(number2);26   }27 }

View Code

静态1

 1 public class StaticDemo 2 { 3   public static void main(String []agrs){ 4     Account acc1=new Account(); 5     acc1.number1++; 6     acc1.showNumber1(); 7     //acc1.showNumber2(); 8      9     10     Account acc2=new Account();11     acc2.showNumber1();12     //acc2.showNumber2();13   }14 }15 16 class Account17 {18   public static int number1=1;//静态变量(类变量),它不属于任何一个对象,被多个对象共享19   public int number2=2;20   public void showNumber1()21   {22     System.out.println(number1);23   }24   public void showNumber2()25   {26     System.out.println(number2);27   }28 }

View Code

静态2

 1 public class StaticDemo 2 { 3   public static void main(String []agrs){ 4     Account.number1++; 5     System.out.println(Account.number1); 6     Account.showNumber1(); 7      8     Account acc1=new Account(); 9     acc1.showNumber2();10     11     Account acc2=new Account();12     acc2.showNumber2();13   }14 }15 16 class Account17 {18   public static int number1=1;//静态变量(类变量),它不属于任何一个对象,被多个对象共享19   public int number2=2;20   //静态方法中不能使用非静态的变量21   //静态方法中不能使用this22   public static void showNumber1()23   {24     //showNumber2();//报错25     System.out.println(number1);26     //System.out.println(this.number2);//报错 27   }28   29   //非静态的方法可以访问静态的内容和非静态的属性和方法30   public void showNumber2()31   {32     showNumber1();33     System.out.println(number2);34     System.out.println("非静态方法访问静态变量:"+number1);35   }36   37   //构造方法38   public Account(){39     System.out.println("constructor");40   }41   42   //static语句块43   //在类被加载时就会执行,只会执行一次,用来对静态的变量赋值44   //优先于构造方法执行45   static{46     System.out.println("static");47     number1=100;48   }49 }

View Code

 

方法重载

多数程序设计语言要求为每个方法(函数)提供一个独一无二的方法名,不存在方法重载的概念

在Java中,规定方法签名是解析方法的规则而不是方法名,为方法重载开创了条件

方法重载使得在一个类中,方法名相同而参数列表不同的方法可同时存在,代表相似的行为和功能

 

重载overload概念:同一类中,同名不同参的方法称为重载方法

注意:仅有返回类型不同的方法不能称为重载,即方法重载必须方法签名不同

 1 public class OverloadDemo{ 2   public static void main(String []agrs){ 3     Printer p=new Printer(2000); 4     p.print("hello");   5     p.print(10); 6     p.print("hello",10); 7   } 8 } 9 10 class Printer{11   private String brand="联想";12   private double price;13   14   public Printer(double price){15     this.price=price;16   }17   18   public Printer(String brand,double price){19     this.brand=brand;20     this.price=price;21   }22 23   public void print(String content){    24     System.out.println("字符串"+content);25   }26   27   public void print(int content){    28     System.out.println("整型"+content);29   }30   31   public void print(String str,int content){    32     System.out.println(str+"--"+content);33   }34   35   public int print(int content,double d){    36     return content;37   }38 }

View Code