目录

  • 一、java项目文件组成
  • 二、封装
  • 1. 概念解释
  • 2. 封装的优点
  • 3. 构造方法


一、java项目文件组成

  1. src：放自己写的代码
    第一层-包：例 com.zyf1007
    第二层：java文件，例 HelloWorld.java
    第三层：类{ } ，例 public class HelloWorld{ }, class Test{ }
  2. out: 放输出的内容
    ①字节码的存储文件夹
    ②运行的字节码文件 .class
  3. 库包： java 本身的类库、导入的其他jar包

二、封装

1. 概念解释

访问权限修饰符：作用于代码编译阶段，限制代码的使用范围(域)

各种访问权限修饰符的作用范围：

  • private 本类中
  • public 整个项目下都可以
  • protected 本包中 、所有的子类中
  • 不写 本包中

封装过程：
①用访问权限修饰符限制属性和方法的使用范围
②然后自己提供不受限制的方法来读写属性

2. 封装的优点

1.读写分离，代码更加规范，例：

private int age;
// 定义public 的方法 读写 属性
    public void setAge(int age){
        if(age<0){
            throw new IllegalArgumentException("age < 0");
        }
        this.age=age;
User user = new User ();
        user.setAge(20);
  1. 限制写入属性值的参数不合法的情况，例如age<0、数据长度超出范围，例：
private int age;
public void setAge(int age){
    if(age<0){
        throw new IllegalArgumentException("age < 0");
     }
    this.age=age;
}
  1. 对传入的参数整合 ，多个值可以整合为一组数据，例如长宽可以合并成一个参数，例：
private Point p;
public void setPoint(int x,int y){
    p = new Point(x, y);
}
  1. 返回数据，对数据做整理。例：数据库中存储数据会简化 时间 - long变量 ，用户需要看到的是 年月日时分秒：
private long time;
public void setTime(long time){
        this.time = time;
    }
public String  getTime(){
        Date date = new Date(time);
        return date.toString ();
}
User user = new User ();
long time = System.currentTimeMillis();
System.out.println (time);
user.setTime (time);
System.out.println (user.getTime ());

3. 构造方法

格式：以类名为方法名，没有返回值结构
用处：针对对象的创建，初始化属性以及必要调用的方法。

书写格式： [权限修饰符] 类名(){ }

规则：

  1. 每个类都有一个隐式的空参数构造方法
  2. 如果显式的写了构造方法，都会覆盖隐式的，不管有无参数
  3. 构造方法是在创建对象时执行，每个对象只有一次构造。
    -每个对象至少调用2个构造方法，因为会调用父系类的构造方法
  4. 构造方法还可以带参数 、以及方法重载（同类中存在多个同名的方法，要求是参数不一致），例如：
private User(String username, String password, int age, long time, Point p){
        this.username = username;
        this.password = password;
        this.setAge (age);
        this.time = time;
        this.p = p;
User user2 = new User ("a", "1", 20, time, new Point (10, 20));
  1. 私有化构造方法：这个类在本类之外不能实例化对象了，例：

父类：学生类，子类：大学生类、中学生类。
学生类比较抽象，不能拥有实例对象。要么私有化构造方法限制，或者直接写出抽象类。

但是在本类中可以创建对象，需要结合static使用。

static : 静态，可修饰属性、方法等。
性质1：唯一性(修饰属性在内存中只存在一份 ) ，不受对象限制。
性质2：由类名可以直接调用。

可以举这样的例子来解释唯一性，无论是直接用类调用的num（UserManage.num）还是创建对象的num（new UserManage ().num）都指向同一个num。

class UserManage{
    static int num;// 只存在一份 不管多少个对象使用的都是同一份
    public static void main(String[] args){
        System.out.println (UserManage.num++);//0
        System.out.println (++new UserManage ().num);//2
        System.out.println (++new UserManage ().num);//3
        System.out.println (UserManage.num);//3
        }
}

static用于对象时为单例模式，一个类只能创建一个对象，一般用于要实例化对象是独一无二的情况。一般分为饿汉和懒汉两种方法：

①饿汉：在类中先实例化好，要用直接获取

private static User king = new User ("King");
public static User getKing(){
    return king;
}

②懒汉：需要用该对象时再实例化（更节约空间，比较推荐）

private static User king1;
    public static User getKing1(){
        if(king1 == null){
            king1 = new User ("King1");
        }
        return king1;
    }

懒汉方法用于不是独一无二的对象时，称为工厂模式。如：

// 工厂模式 每次调用都能获取一个新的对象 
public static User getUser(int id){
    return new User("id");
}