乐趣区

关于java:建议收藏关于面向对象封装还没有见过总结的这么详细的

类和对象

什么是类

类是一组相干属性和行为的汇合,能够看作是一类事物的模板,比如说:无论中年人、老年人还是小孩,都有身高、体重(这是属性),都会吃饭、睡觉(这是行为),那么咱们就能够抽取出这些共有的属性和行为,封装为一个类。类由两局部组成:

  • 属性:事物的状态信息
  • 行为:事物可能做啥

什么是对象

对象是某类事物的具体体现,对象是类的一个实例,比如说:一株蒲公英是动物类的具体实例。

对象和类的关系

  • 类是对象的形象
  • 对象是类的具体

类的定义

格局

修饰符 class 关键字 类名{
    // 成员变量(属性)// 成员办法(行为)}

定义类

public class Student{
    String name;// 姓名
    int age;// 年龄

    // 吃饭
    public void eat(){System.out.println("吃饭");
    }
}

Student 是类名,name 和 age 是成员变量(属性),定义的形式和申明一般变量一样;eat 是成员办法(行为)。

创立和应用对象

格局

类名 对象名 =new 类名();
public static void main(String[] args){
    // 创立 Student 类实例
    Student s=new Student();
    // 应用成员变量
    System.out.println(s.name);//null
    System.out.println(s.age);//0
    // 调用 eat 办法
    s.eat();}

成员变量的默认值

如果没有对成员变量进行赋值的话,那么将会应用它们的默认值

public class Student {
    int age;
    float weight;
    char sex;
    boolean isMan;
    String name;

    public void eat(){System.out.println("吃饭");
    }

    public static void main(String[] args) {Student s=new Student();
        System.out.println(s.age);//0
        System.out.println(s.weight);//0.0
        System.out.println(s.isMan);//false
        System.out.println(s.name);//null
        System.out.println(s.sex=='\u0000');//true
    }
}

局部变量

局部变量在办法外部定义

public class Student {
    int age;

    public void say(){
          // 定义局部变量 a
        int a=1;
        System.out.println(a);
    }
      // 形参也是局部变量
      public void hel(int a){System.out.println(a);
    }
}

成员变量和局部变量的区别

  • 在类中的地位不同

    成员变量定义在类中、办法外

    局部变量定义在办法中或办法申明上(形参)

  • 作用范畴不同

    成员变量作用范畴是整个类

    局部变量的作用范畴是它所在的办法

    public class Student {
        int age;
    
        public void say(){
              // 定义局部变量 a
            int a=1;
            System.out.println(age);
            System.out.println(a);
        }
    
        public void hel(){System.out.println(age);
            //System.out.println(a);  无法访问到 a
        }
    
    }
    
  • 是否有默认值

    成员变量有默认值

    局部变量没有默认值,必须定义赋值,而后应用

     public void say(){
            int a;
            //System.out.println(a);  未赋值无奈应用
        }
    
  • 在内存的地位

    成员变量在 堆内存

    局部变量在 栈内存

  • 生命周期不同

    成员变量随着对象的创立而存在,随着对象的隐没而隐没

    局部变量随着办法的调用而存在,办法调用结束它便隐没

封装概述

封装是指将数据和操作数据的办法绑定起来,对数据的拜访只能通过定义的接口。咱们在类中编写的办法就是对实现细节的一种封装;咱们编写的类就是对数据和数据操作的封装。

封装步骤

  • 应用 private 修饰符将变量润饰为公有变量(只有本类中能够拜访)
  • 对外提供私有的能够拜访公有变量的办法,如 getXXX()办法和 setXXX()办法

    public class Test1 {public static void main(String[] args) {Person p=new Person();
            //System.out.println(p.name);  无奈间接拜访
            System.out.println(p.getName());//null 只能通过对外提供的接口进行拜访
        }
    }
    
    class Person{
        private String name;
        private int age;
    
        public String getName() {return name;}
    
        public void setName(String name) {this.name = name;}
    
        public int getAge() {return age;}
    
        public void setAge(int age) {this.age = age;}
    }
    

    留神

    一个.java 文件中能够定义多个类,然而只能有一个类应用 public 修饰符

    this 关键字代表正在操作的那个对象,this.name 示意该对象的成员变量 name,区别于局部变量 name

构造方法

咱们晓得,想要应用对象内的货色,必须要先应用 new 关键字创建对象,那么它是怎么创立进去的呢?答案就是构造方法,可是咱们的类中没有定义构造方法啊?尽管没有定义,然而咱们每个类都有一个默认值的无参构造方法,咱们在 new 对象的时候就会调用构造方法。那么咱们该如何定义本人的构造方法呢?

#### 格局

【修饰符】类名(【参数列表】){// 代码}

#### 留神点

    • 构造方法的名字必须和类名统一
    • 构造方法没有返回值(其实是省略了,因为构造方法只能返回本类的类型)
    • 一旦本人 DIY 了构造方法,那么默认的无参构造方法就有效了
    • 没有参数列表的是无参构造方法,有参数列表的是有参构造方法
    • 咱们能够在一个类中定义多个构造方法

         public class Test1 {public static void main(String[] args) {
                // 应用无参结构创建对象
                 Person p1=new Person();
                 // 应用有参结构创建对象
                 Person p2=new Person("张三");
             }
         }
      
         class Person{
             private String name;
             private int age;
      
             // 无参构造方法
             public Person(){System.out.println("我是无参构造方法");
             }
      
             // 我是有参构造方法
             public Person(String name){System.out.println(name);
                 System.out.println("我是有参构造方法");
             }
      
         }
      

    执行后果:

    我是无参构造方法
    张三
    我是有参构造方法

    #### 应用结构实现封装

    后面通过编写 setXXX 办法和 getXXX 办法以及私有化成员变量实现封装,这里咱们通过构造方法实现封装

       class Person{
           private String name;
           private int age;
    
           // 无参构造方法
           public Person(){System.out.println("我是无参构造方法");
           }
    
           // 我是有参构造方法
           public Person(String name,int age){System.out.println("我是有参结构");
               this.name=name;
               this.age=age;
           }
       }
       public class Test1 {public static void main(String[] args) {
              // 应用无参结构创建对象
               Person p1=new Person();
               // 应用有参结构创建对象
               Person p2=new Person("张三",23);
           }
       }
    

    咱们无法访问对象的成员变量(属性),只能通过结构进行拜访

    JavaBean

    JavaBean是 java 语言编写类的一种 标准规范,合乎JavaBean` 的类必须要满足以下条件:

    • 类必须是具体和公开的(应用 public 润饰)

      • 类必须有无参构造方法(有参结构倡议加上)
    • 必须要有操作成员变量的 setXXX 办法和 getXXX 办法

         class Person{
             private String name;
             private int age;
      
             // 无参构造方法
             public Person(){System.out.println("我是无参构造方法");
             }
      
             // 我是有参构造方法
             public Person(String name,int age){System.out.println("我是有参结构");
                 this.name=name;
                 this.age=age;
             }
      
             public String getName() {return name;}
      
             public void setName(String name) {this.name = name;}
      
             public int getAge() {return age;}
      
             public void setAge(int age) {this.age = age;}
         }
      

    最初

    感激你看到这里,文章有什么有余还请斧正,感觉文章对你有帮忙的话记得给我点个赞,每天都会分享 java 相干技术文章或行业资讯,欢送大家关注和转发文章!

    退出移动版