侧边栏壁纸
博主头像
coydone博主等级

记录学习,分享生活的个人站点

  • 累计撰写 306 篇文章
  • 累计创建 51 个标签
  • 累计收到 0 条评论

目 录CONTENT

文章目录

封装和访问修饰符

coydone
2021-01-04 / 0 评论 / 0 点赞 / 255 阅读 / 4,574 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-05-01,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

封装

目的:提高数据安全性,通过封装,可以实现对属性的访问权限控制,同时增加了程序的可维护性。它将类的状态信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的步骤:

1、修改属性的可见性。将属性私有化,使用private关键字完成属性私有化,这种属性只有本类能访问

2、设置setter/getter方法。我们一般对每一个私有属性提供公共public的setter/getter方法供外界来访问我们的私有属性。

3、设置属性的存取限制。对属性设置合法性检验,需要在setter方法中进一步利用条件判断语句进行赋值限制。

public class Person {//定义人类
    //私有化属性
    private String name;//姓名
    private  String gender;//性别
    private int age;//年龄
	
    //getter/setter方法封装
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    //设置性别存取值只能为男或者女
    public void setGender(String gender) {
        if(gender.equals("男")||gender.equals("女")){
            this.gender = gender;
        }else{
            System.out.println("性别不合法!");
        }
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
	
    //构造方法初始化数据
    //无参构造
    public Person(){
        this.name = "张三";
        this.gender = "男";
        this.age = 18;
    }
    //有参构造
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
	
    public void say(){
        System.out.println("姓名:"+this.name+"性别:"+this.gender+"年龄:"+this.age);
    }
}

public class Test {
     //测试类中调用Person类
     public static void main(String[] args) {
        Person person = new Person();
        person.setAge(23);
        person.say();
//打印:姓名:张三性别:男年龄:23
    }
}

包机制

package

包帮助管理大型软件系统,将语义近似的类组织到包中。包可以包含类和子包。相当于我们在电脑上创建一个文件夹,而里面存放的是.java文件。

Java中包的使用:

  • package语句:作为Java源文件类中的第一条语句,指明该文件中定义的类所在的包。

  • 格式:package 包名;

包名基本上用小写字母,可以有多个包,通过包名.子包名的形式命名。

import

如果我们要使用其它包的类,需要使用import导入,从而可以在本类中直接通过类名来调用,否则就需要书写类的完整包名和类名。import后,便于编写代码,提高程序可维护性。

Java会默认导入java.lang包下所有的类,因此这些类我们可以直接使用。

如果导入两个同名的类,只能用包名+类名来显示相关类:

import java.sql.Date;
//导入该包下的所有的类,会降低编译速度,但不会降低运行速度
import java.util.*; 

java.util.Date date = new java.util.Date();

静态导入

静态导入(static import)是在JDK1.5新增加的功能,其作用是用于导入指定类的静态属性,这样我们可以直接使用静态属性。

//导入Math类的PI属性
import static java.lang.Math.PI;

//导入Math类下的所有静态属性
import static java.lang.Math.*;

访问修饰符

类和类成员的访问控制

类的访问修饰符(√表示可以使用,×表示不可以使用)

修饰符\作用域 同一包中 非同一包中
public
默认修饰符 ×

类成员的访问修饰符(√表示可以使用,×表示不可以使用)

修饰符\作用域 同一类中 同一包中 子类中 其它
private × × ×
默认修饰符 × ×
protected ×
public

【注】关于protected 的两个细节:

  • 若父类和子类在同一个包中,子类可访问父类的protected成员,也可访问父类对象的protected成员。

  • 若子类和父类不在同一个包中,子类可访问父类的protected成员,不能访问父类对象的protected成员。

static关键字

一个类可以被创建n个对象,如果n个对象中的某些数据需要共用,就需要使用static关键字修饰这些数据。

修饰在属性上

语法:static数据类型 变量名。使用static修饰的属性我们认为是类的属性,不带static修饰的属性我们认为是对象的属性。类属性访问:类名.类属性(推荐使用)、对象实例.类属性

应用的场景:我们把常量一般定义成static,或者当前类创建的每一个对象都有相同的属性也可以把这种属性定义成static的。

static在属性内存中的加载流程:

static在属性的生命周期:

对象属性生命周期:创建对象的时候初始化对象属性(没有类属性早),当当前对象变成匿名对象时,JVM会回收该垃圾对象,对象属性随之消失。

类属性的生命周期:当Person.class被载入内存时,personNum类属性就初始化了,JVM关闭,类属性就消失了。

修饰在方法上

语法:

public static 返回值(void) 方法名(数据类型1 变量1,数据类型2 变量2...){
    方法体 
    [return 结果]              
} 

static修饰在方法上就是类方法或者称为静态方法,不用static修饰的方法称为实例方法。

类方法的访问:类名.类方法()推荐使用、对象实例.类方法()

注意:在静态方法中不能直接访问实例变量和实例方法。

在实例方法中可以直接调用类中定义的静态变量和静态方法。

public class Person {//定义人类
    public String name;//姓名
    public String gender;//性别
    public static int age;//年龄
    public static void show(String name,String gender,int age){
        System.out.println("姓名:"+name+",性别:"+gender+",年龄:"+age);
    }
}
public class Test {
    //测试类中调用Person类
    public static void main(String[] args) {
        Person person = new Person();
        Person.show("张三","男",23);
        //打印:姓名:张三,性别:男,年龄:23
    }
}

静态代码块

语法:

class A{
    //静态代码块
    static{
    }
}

静态代码块主要是用于初始化资源。静态代码块在main之前执行。静态代码块可以范围类属性(必须先定义)和类方法。

 public class TestStatic{
     String name;
     public void method(){
	
     }
     static int age;
     public static void method1(){
         System.out.println("静态方法被调用了");
     }
     //不能访问对象属性和方法
     static{
         System.out.println("静态代码块被执行了");
         System.out.println(age);
         method1();
     }
     public static void main(String[] args){
         System.out.println("主方法执行");
     }
 }
 //静态代码块被执行了
 //0
 //静态方法被调用了
 //主方法执行

单例模式

设计模式:一共有**23种设计模式 **,设计模式就是有经验的前人通过实践总结下来被大家公认的代码设计思想。

单例模式作用:保证一个类只有一个实例,并且提供一个访问该实例的全局访问入口。

Windows的任务管理器、Windows的回收站,就是一个单例应用。

实现步骤

1、私有化构造器。

2、定义一个类方法用于获得单例的对象,返回值是这个类的类型。

3、提供一个公有的静态方法,返回实例对象。

4、实现这个类方法。

懒汉式

class Singleton{
    //2.本类内部创建对象实例
    private static Singleton s;
    //1.构造方法私有化,外部不能new
    private Singleton(){
    }
    //懒汉
    //3.提供一个公有的静态方法,返回实例对象
    public static Singleton getInstance(){
        if(s == null){
            s = new Singleton();
        }
        return s;
    }
}

public class TestSingleton{
    public static void main(String[] args){
        Singleton s = Singleton.getInstance();
        System.out.println(s);
        Singleton s1 = Singleton.getInstance();
        System.out.println(s1);
    }
    //Singleton@1540e19d
    //Singleton@1540e19d
}

饿汉式

//饿汉模式
class Singleton{
    private static Singleton s = new Singleton();
	
    private Singleton(){
    }
    //饿汉
    public static Singleton getInstance(){
         return s;
    }
}
0

评论区