Java面向对象 学习笔记 (二) 封装

Java面向对象 (二) 封装

• 在Java中，设计类就必须要学会封装

• 所谓封装： 通俗的将就是告诉我们，如何正确的设计对象的属性和方法。

• 封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

   前面那一篇文章简要的介绍了一下类，这里将带你们写一个封装的类。
   完整的类包含以下几点：
  

1.成员变量

每个类一般都会有几个成员变量：
成员变量有两种：
	1.实例成员变量：
			是定义在方法外部和类内部的且不被static所修饰的变量.用于描述一个类中包含哪些数据
		private String name;
		private int age;
		private double height;
	2.静态成员变量:
		 static关键字修饰成员变量，简称静态成员变量，又称类变量
 			1.访问方式：通过类名.静态成员变量名进行访问
 			2.内存的存储方式：方法区
 			3.特点：静态的只有一份，且不依赖对象
		private static int money;
类中成员变量有一个和局部变量不一样的特点：
				1.成员变量有默认值，无需初始化
				2.局部变量没有默认值，使用前需要初始化
				
成员变量一般无需初始化，存在默认值
    byte short int long   0
    double float          0.0
    boolean               false
    String 等引用类型      null

2.成员方法

方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用。
//举个代码案例
public class Demo01 {
    //主方法
    //方法的编写顺序无所谓
    //方法与方法之间是平级关系不能进行嵌套
    //方法必须调用才能执行
    public static void main(String[] args){
		//有参有返回值 用一个返回值类型的变量接收 并填上参数sum(10,20);
        int c = sum(10,20);
        System.out.println(c);
        //无返回值 无参 直接调用 print();
        print();
    }
    //方法 有参有返回值
    public static int sum(int a,int b){
        int c = a+b;
        return c;
    }
    //无返回值 无参 方法
    public static void print(){
        for(int i=0;i<5;i++){
            System.out.println("Hello world");
        }
    }
}
//一个类中如果有多个方法时，方法名可以重复，这是方法重载的一个小知识点
方法重载 ：同一个类中，出现 名称 相同，但是 形参 不一样，那么这些方法就是重载(与返回值类型无关)

3.构造器

 定义在内中，可以用来初始化一个内的对象，并返回对象的地址
 //构造器的格式
修饰符 类名(形参列表){
    ...
}
public class Car {
    String name;
    double price;
    //构造函数
    //无参构造器
    public Car(){
        System.out.println("--无参构造器被调用了--");
    }
    //有参构造器
    public Car(String n,double p){
        System.out.println("--有参构造器被调用了--");
        name = n;
        price = p;
    }
}
**注意：**
一旦定义有参数构造器，那么无参构造器就没有了
如果还想用无参构造器需要自己手写一个

4.代码块

//实例代码块几乎不用 静态代码块用的多一点
//下面是代码案例 
public class Demo {
    public static ArrayList<String> cards = new ArrayList<>();
    /**
     * 静态代码块： 有static修饰，属于类，与类一起优先加载一次，自动触发执行。
     * 作用：可以用于初始化静态资源。(实例资源不行)
     * 格式 static{}
     */
    static{
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] colors = {"♥","♠","♦","♣"};

        for (int i = 0; i < sizes.length; i++) {
            for (int j = 0; j < colors.length; j++) {
                String card = sizes[i] + colors[j];
                cards.add(card);
            }
        }
        cards.add("小🃏");
        cards.add("大🃏");
    }

    /**
     * 构造代码块 也叫 实例代码块
     * 每次创建对象，属于对象，调用构造器执行时，都会执行改代码块中的代码，并在构造器执行前执行
     * 格式：{}
     */
     {
     	System.out.println("==========实例代码块执行==========");
     	schoolName = "清华大学";
     }
    public static void main(String[] args) {
        System.out.println("==========main方法执行==========");
        System.out.println(schoolName);
        System.out.println("新牌："+cards);
    }
}

5.内部类

//匿名内部类：
    本质上是一个没有名字的局部内部类，定义在方法中，代码块中，等。
//作用
      //方便创建子类对象，最终目的为了简化代码编写。
        
格式：
        new 类|抽象类名|或者接口名(){
        重写方法;
    };

Employee a = new Employee(){
    public void work(){
	}
};
a.work;

//匿名内部类的基本形式

public class Test {
    public static void main(String[] args) {
        //匿名内部类
        Animal a = new Animal(){
            @Override
            public void run(){
                System.out.println("老虎跑的快~~~");
            }
        };
        a.run();
    }

}

• 介绍完上面几点，我们回到封装
• 简洁的说封装是将成员变量私有
• 提供成套的getter和setter方法暴露其取值和赋值

JavaBean   也可以称为实体类，其对象可以用于在程序中封装数据。
	-1. 标准JavaBean的书写要求
	-2. 成员变量使用private 修饰。
	-3. 提供成员变量对应的setXxx()/getXxx() 方法。
	-4. 必须提供一个无参构造器(无参构造函数); 有参构造器可写可不写。
//以下是标准JavBean的书写格式

public class Car {
    /**成员变量*/
    private String name;
    private double height;
    private double salary;

    /**
        参数构造器(构造函数)
        开始是默认有无参构造函数的
        一旦定义有参数构造器，那么无参构造器就没有了
        如果还想用无参构造器需要自己手写一个
    */
    /**无参构造*/
    public Car() {

    }
    /**有参构造参构造*/
    public Car(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }

    /**
     提供成套的getter和setter方法暴露其取值和赋值
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

以上是封装一个类的标准写法，初学者可以参考这个格式。
代码块和内部类根据实际情况写，需要的话再写

关于封装就简单介绍到这里，关注我，后续会更加精彩！！！
本人学习笔记仅供参考，如有错误请及时指出，谢谢！！！