java封装

封装

一,封装的作用

封装,就是隐藏实现细节 将对象的属性和方法通常被封装在一起，共同体现事物的特性， 二者相辅相承，不能分割 将属性私有化，提供公有方法访问私有属性 通过这些公有方法访问私有属性 ,从而保证数据的安全，提高代码的可维护性

二,实现

封装的实现：

1、修改属性的可见性来限制对属性的访问

2、为每个属性创建一对赋值(setter)方法和取值(getter) 方法，用于对这些属性的访问

3、在setter和getter方法中，加入对属性的存取限制

使用封装类

package com.sk.test;
​
/**
 * ClassName: Teacher <br/>
 * Description: <br/>
 * date: 2021/11/24 8:28<br/>
 *
 * @author 斑马<br />
 */
public class Teacher {
    //1.私有化属性   private修饰符修饰的属性和方法只能在本类中访问
    private String name;
    private int age;
    //2.给私有的属性提供 共有(public)的访问方法
    //共有的设置name值的方法
    public void setName(String name){
        this.name=name;
    }
    //共有的取值方法
    public String getName(){
        return name;
    }
    public void setAge(int age){
        if(age<26){//在设置值的时候限制字段
            System.out.println("年龄小于26,默认为26");
            this.age=26;
        }else {
            this.age = age;
        }
    }
    public int getAge(){
        return age;
    }
}
​

 *
 * @author 斑马<br />
 */
public class TeacherTest {
    public static void main(String[] args) {
        Teacher teacher=new Teacher();
        //直接通过属性无法访问
        //teacher.name="张三";
        teacher.setName("张三");
        teacher.setAge(32);
        String name=teacher.getName();
        int age=teacher.getAge();
        System.out.println("姓名:"+name+"\t年龄:"+age);
        System.out.println("姓名:"+teacher.getName()+"\t年龄:"+teacher.getAge());
    }
}

​

使用封装，增加了数据访问限制，增强了程序的可维护性

1.给属性赋值需要通过 对象名.setXxx()

2.获取属性的值需要通过 对象名.getXxx()

二,构造方法

构造方法负责对象成员的初始化工作，为实例 变量赋予合适的初始值 构造方法必须满足以下语法规则： 1、方法名与类名相同 2、没有返回类型

package com.sk.test;
​
/**
 * ClassName: Book <br/>
 * Description: <br/>
 * date: 2021/11/24 9:59<br/>
 *
 * @author 斑马<br />
 */
public class Book {
    /**无参构造*/
    public Book(){//系统会为每一个类默认一个无参构造,new 对象会执行构造方法
        System.out.println("无参构造执行了");
    }
    /**有参构造*/
    public Book(String title,int pageNum){
        //通过有参构造给对象赋值
        this.title=title;
        this.pageNum=pageNum;
    }
    
    private String title;
    private int pageNum;
    public void show(){
        System.out.println("标题:"+title+"\t"+pageNum);
    }
    //Alt+Insert  +  getter and setter
    public String getTitle() {
        return title;
    }
​
    public void setTitle(String title) {
        this.title = title;
    }
​
    public int getPageNum() {
        return pageNum;
    }
​
    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }
​
}

​
​

三,方法重载

1.在同一个类中

2.方法名相同

3.参数列表不同

4.和修饰符以及返回值类型无关

package com.sk.test;
​
/**
 * ClassName: Driver <br/>
 * Description: <br/>
 * date: 2021/11/24 14:24<br/>
 *
 * @author 斑马<br />
 */
public class Driver {
    public void a(){
        System.out.println("驾驶");
    }
    public void a(int a){
        System.out.println("驾驶一个"+a+"人的大巴");
    }
    public void a(int b,double money){
        System.out.println("驾驶一个"+b+"人的每公里"+money+"元的出租车");
    }
}
​
package com.sk.test;
​
/**
 * ClassName: Master <br/>
 * Description: <br/>
 * date: 2021/11/24 14:28<br/>
 *
 * @author 斑马<br />
 */
public class Master {
    public void feed(){
        
    }
    public void feed(Cat c){
        System.out.println("喂养猫");
    }
    public void feed(Dog c){
        System.out.println("喂养猫");
    }
    public void feed(Pig c){
        System.out.println("喂养猫");
    }
}
class Cat{}
class Dog{}
class Pig{}

static关键字

package com.sk.test;
​
/**
 * ClassName: StaticTest <br/>
 * Description: <br/>
 * date: 2021/11/24 15:37<br/>
 *
 * @author 斑马<br />
 */
public class StaticTest {
    StaticTest(){
​
    }
    StaticTest(int a,int b){
        this.a=99;
        this.b=100;
    }
    {//非静态的代码块
        b=12;
    }
    static {
        //静态代码块不能给非静态属性赋值
        //b=22;
        a=78;
    }
​
    //静态变量,属于类对象,不再属于对象的属性
    static int a;
    int b;
    /*public static StaticTest(int b) {
        this.b = b;
    }*/
    /**非静态方法*/
    public static void a(){
        //静态方法不能直接使用非静态属性
        //System.out.println(b);
        //静态方法不能直接调用非静态方法,只能调用静态方法和对象方法
        //b();
        /*StaticTest t=new StaticTest();
        t.b();*/
        System.out.println("静态方法");
    }
    public void b(){
        //普通方法可以直接使用静态属性
        System.out.println(a);
        //普通方法可以直接使用静态方法
        a();
        System.out.println("非静态方法");
    }
}
​

package com.sk.test;
​
/**
 * ClassName: Test <br/>
 * Description: <br/>
 * date: 2021/11/24 15:51<br/>
 *
 * @author 斑马<br />
 */
public class Test {
    public static void main(String[] args) {
        StaticTest s=new StaticTest();
        s.b=12;
        //s.a=9;
        StaticTest.a=12;
        s.a=33;
        System.out.println(s.a);
        s.b();
        s.a();
        StaticTest.a();
        StaticTest ss=new StaticTest();
        System.out.println(ss.a);
        System.out.println(ss.b);
    }
}
​

类的加载顺序

1.先加载属性和方法

2.加载构造函数

3.加载代码块

代码块的作用

给属性赋值(给属性一个默认值)