类和对象（2）

1包

1.1包的概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。java中也引入了包，包是对象，接口的封装机制的体现，是一种对类或者接口的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

1.2导入包中的类

java中提供了很多现成的类供我们使用，可以使用import导入包。

import java.util.Date;
public class text1{
    public static void main(String[] args){
     Date data=new Date();//得到一个毫秒级别的时间戳
        System.out.println(data.getTime());
    }
}

如果还要使用java.util中的其它类，可以使用import java.util.*

import java.util.*;
public class text1{
    public static void main(String[] args){
     Date data=new Date();//得到一个毫秒级别的时间戳
        System.out.println(data.getTime());
    }
}

 使用时更加建议显示要导入类的名字，否则有时会出现冲突的情况。

import java.sql.*;
import java.util.*;
public class text1{
    public static void main(String[] args){
     Date data=new Date();//得到一个毫秒级别的时间戳
        System.out.println(data.getTime());
        //这两个包中都有Date类，会出现编译错误。
    }
}

为了使编译正确，需要使用完整的类名

import java.sql.*;
import java.util.*;
public class text1{
    public static void main(String[] args){
     java.util.Date data=new java.util.Date();//得到一个毫秒级别的时间戳
        System.out.println(data.getTime());
        //这两个包中都有Date类，会出现编译错误。
    }
}

可以使用import static 导入包中静态的方法和字段。

import static java.lang.Math.*;
public class text1{
    public static void main(String[] args){
        int a=12,b=9;
        double c=sqrt(pow(a,2)+pow(b,2));
        System.out.println(c);
    }
}

 1.3自定义包

基本规则：1.在文件的最上方加一个package语句指定该代码在那个包当中。

                   2.包名需要尽量指定成唯一的名字，通常会用公司域名的颠倒形式。

                   3.包名要和代码路径匹配。

                   4.如果一个类没有package类，则该类被放到一个默认包中。

1.3包的访问权限控制举例

package com.lisi.demo2;
import com.lisi.demo1.text1;
public class text2 {
    public static void main(String[] args){
        text1 p=new text1("as","as","aa","sd");
        p.fun1();
        //System.out.println(p.a1);
        System.out.println(p.a2);
        //会报错，a1被private修饰，不允许在不同的包中的访问；
    }



}

 2.static成员

先书写一个学生类

package com.lisi.demo2;

public class student {
    String name;
    String sex;
    int age;
    public student(String name,String sex,int age){
        this.name=name;
        this.sex=sex;
        this.age=age;
    }
    public static void main(String[] args){
        student a1=new student("lisi","nan",12);
        student a2=new student("zhangsan","nv",22);
    }
}

假设这三个同学是一个班上的，需要在同一个教室中上课，上图student类中定义的成员变量，每个对象中都会包含一份（实例变量），因为需要使用这些信息来描述具体的学生，现在要描述学生上课的教室，教室这个量并不需要每个学生成员对象中都储存一份，而是需要让所有的学生来共享。在java中，被static 修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象共享的。

2.2 static修饰成员变量。

static 修饰的成员变量，称为静态成员变量，静态成员变量的最大的特性：不属于某个具体的对象，而是所有的对象共享的。

静态成员变量特性：

1.不属于某个类具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。

2.既可以通过对象访问，也可以通过类名访问，但一般推荐使用类名访问。

3.类变量存储在方法去当中。

4.生命周期伴随类的一生，随类的创建而创建，随类的销毁而销毁。

package com.lisi.demo2;

public class student {
    String name;
    String sex;
    int age;
    static String room="3-21";
    //静态成员变量是所有对象所共享。
    public student(String name,String sex,int age){
        this.name=name;
        this.sex=sex;
        this.age=age;
    }
    public static void main(String[] args){
        student a1=new student("lisi","nan",12);
        student a2=new student("zhangsan","nv",22);
        System.out.println(student.room);
        System.out.println(a1.room);//也可以通过对象访问，但推荐通过类名访问
        System.out.println(a2.room);
    }
}

//static 修饰的静态成员变量存储在方法区中。

2.3static修饰成员方法

一般类中的成员变量都设置为private，成员方法都设置为public,那么设置之后，student类中的room属性如何在类外访问？

package com.lisi.demo2;
class student1{
    private String name;
    private String sex;
    private int age;
    private static String room="2-21";
}
public class student{
    public static void main(String[] args){

     student1 a1=new student1();
     System.out.println(student1.room);
    }

}

 

 使用类名访问，会出现以上报错。

那static属性应该如何访问？

java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

package com.lisi.demo2;
class student1{
    private String name;
    private String sex;
    private int age;
    private static String room="2-21";
    private static int tt=12;
    public static String getroom(){
        return room;
    }
    public static int gett(){
        return tt;
    }
}
public class student{
    public static void main(String[] args){

     student1 a1=new student1();
     System.out.println(student1.gett());
     System.out.println(student1.getroom());
    }

}

静态方法的属性：

1.不属于某个具体的对象，是类方法

2.推荐使用类名.静态方法名调用

3.不能在静态方法中访问任何非静态成员变量。即无法在静态上下文中引用非静态。

2.4 static 成员变量的初始化

注意：静态成员变量一般不会放在构造方法中初始化，构造方法中初始化的是与对象相关的实例属性。

静态长远变量的初始化分为两种：就地初始化和静态代码块初始化

3.代码块

3.1代码块的概念及分类

使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块      构造块       静态块       同步代码块 

3.2普通代码块

普通代码块：定义在方法中的代码块。

public static void main(String[] args){
      //普通代码块
     student1 a1=new student1();
     System.out.println(student1.gett());
     System.out.println(student1.getroom());
    }

3.2构造代码块

构造代码块：定义在类中的代码块（不加修饰符）。也叫：实例代码块。构造代码块一般用于实例化成员变量。

class student1{
    private String name;
    private String sex;
    private int age;
    private static String room="2-21";
    private static int tt=12;
    public static String getroom(){
        return room;
    }
    //示例代码块
    {
        this.age=12;
        this.name="lisi";
        this.sex="男";
        
    }
    public static int gett(){
        return tt;
    }
}

3.3静态代码块

使用static定义的代码块称为静态代码块，一般用于初始化静态成员变量。

class student1{
    private String name;
    private String sex;
    private int age;
    private static String room="2-21";
    private static int tt=12;
    public static String getroom(){
        return room;
    }
    //示例代码块
    {
        this.age=12;
        this.name="lisi";
        this.sex="男";
        
    }
    public static int gett(){
        return tt;
    }
}

注意：静态代码块不管生成多少个对象，只会执行一次