疯狂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 Teacher
14 {
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         else
30         {
31             age=tage;
32         }
33     }
34     public int getAge(){
35         return age;
36     }
37 }
复制代码
 
 
类的构造方法的概念和作用
 
①   构造方法负责对象初始化工作,为对象的属性赋合适的初始值;
 
②   创建对象时,其类的构造方法确保在用户操作对象之前,系统保证初始化的进行;
 
构造方法的语法规则
 
①   构造方法名与类名相同
 
②   没有返回类型
 
③   方法实现主要为字段赋初值
 
构造方法的调用和特别: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 Person
13 {
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 }
复制代码
带参构造方法
 
 
复制代码
 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 Person
14 {
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 }
复制代码
 
 
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 Person
11 {
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=0
28         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 }
复制代码
 
 
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 Account
16 {
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 }
复制代码
静态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 Account
17 {
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 }
复制代码
静态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 Account
17 {
18     public static int number1=1;//静态变量(类变量),它不属于任何一个对象,被多个对象共享
19     public int number2=2;
20     //静态方法中不能使用非静态的变量
21     //静态方法中不能使用this
22     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 }
复制代码
 
 
方法重载
 
多数程序设计语言要求为每个方法(函数)提供一个独一无二的方法名,不存在方法重载的概念
 
在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 }
复制代码