【知识梳理】Java类、访问级别、包、导入

不念不忘少年蓝@ 2022-11-26 12:00 9阅读 0赞

### 文章目录 ###

*  Java类
 *   *  Java 类实例
     *   *   *  null引用类型
             *  Java原始类型和引用类型
             *   *   *  1. 原始类型
                     *  2. 原始类型和引用类型的区别
             *  访问类的字段的点表示法
             *  字段的默认初始化
     *  Java 访问级别
 *  Java包
 *   *  Java 导入
     *   *   *  静态导入声明

# Java类 #

## Java 类实例 ##

以下是创建类的实例的一般语法:

new <Class Constructor>;

new 运算符后面是对构造函数的调用。  
**new 运算符通过分配堆上的内存来创建类的实例。**  
以下语句创建Dog类的实例:

new Dog();

Dog()是对Dog类的构造函数的调用。

当我们不向类添加构造函数时，Java编译器为我们添加一个。

Java编译器添加的构造函数称为默认构造函数。默认构造函数不接受参数。

类的构造函数的名称与类名称相同。

**new运算符为类的每个实例字段分配内存。类静态变量在创建类的实例时不会分配内存。**

要访问类的实例的实例变量，我们必须有它的引用。

类的名称在Java中定义了一个新的引用类型。特定引用类型的变量可以存储相同引用类型的实例的引用。

声明一个引用变量，它将存储Dog类的实例的引用。

Dog anInstance;

Dog是类名，它也是一个引用类型，并且 anInstance 是该类型的变量。

anInstance是Dog类型的引用变量。anInstance变量可用于存储Dog类的实例的引用。

new运算符为类的新实例分配内存，并返回对该实例的引用。

我们需要将由new运算符返回的引用存储在引用变量中。

anInstance = new Dog();

#### null引用类型 ####

我们可以为任何引用类型的变量分配一个空值。空值意味着引用变量是指**没有对象**。

Dog  obj  = null;  // obj  is not  referring to any  object
    obj  = new Dog();  // Now, obj  is referring to a  valid Dog  object

您可以使用一个空文字与比较运算符来检查是否相等和不等。

if  (obj == null)  {
        
        //obj is null
    }
    
    if  (obj !=  null)  {
        
        //obj is not null
    }

Java不会混合引用类型和原始类型。我们不能给一个**原始类型变量赋null**。

#### Java原始类型和引用类型 ####

在Java中提供了两种数据类型：原始类型和引用类型。

###### 1. 原始类型 ######

Java中的原始类型是不同于类的**基本数据类型**，包括如下8种基本类型：double、float、byte、short、int、long、char、boolean。这8种 原始类型**直接存储在Java的内存栈**中，数据本身的值也是存储在栈中，即当声明了一个原始类型时，就在栈中为类型本身申请了存储。

同时，Java为每个原始类型提供了对应的封装类型，分别如下：

<table> 
 <thead> 
  <tr> 
   <th>原始类型</th> 
   <th>封装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

Java中针对原始数据类型提供了对应的封装类，**因为**

1.  在类中可以定义一些必要的方法，用于实现基本数据类型的数值与可打印字符串之间的转换，以及一些其他的实用程序方法；
2.  另外，有些数据结构库类只能操作对象，而不支持基本数据类型的变量，包装类提供一种便利的方式，能够把基本数据类型转换成等价的对象，从而可以利用数据结构库类进行处理

###### 2. 原始类型和引用类型的区别 ######

1.  大小和速度问题，使用原始类型无须调用 new，也无须创建对象，这节省了时间和空间。
2.  另外，对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
3.  针对“=”本身，对这两种数据类型是没有本质区别的，都是"="左右的值等于右边的值，但不同的是，针对引用类型，赋值符“=”改变的是对象引用，而不是对象本身，也就是说当下面程序执行完之后，
    
        Point pOne = new Point(5,5);  //引用类型
        Point pTwo = new Point(6,6);  //引用类型
        pOne = pTwo;
    
    pOne和pTwo，均指向了同一个对象，因此对pOne的任何操作，同时也会影响到pTwo。

> 参考链接：https://blog.csdn.net/forever7107/article/details/51590051

#### 访问类的字段的点表示法 ####

点符号用于引用实例变量。  
obj.name引用obj引用变量引用的实例的名称实例变量。

要为名称实例变量分配值，请使用

obj.name = "Rectangle";

以下语句将name实例变量的值分配给String变量aName:

String aName = obj.name;

要引用类变量，请使用类的名称。

ClassName.ClassVariableName

#### 字段的默认初始化 ####

类的所有字段（静态以及非静态）都将初始化为默认值。

**字段的默认值取决于其数据类型。**

*  数字字段（byte, short, char，int，long，float和double）初始化为0。
 *  boolean初始化为false。
 *  引用类型字段初始化为null。

## Java 访问级别 ##

当我们通过简单的名称引用一个类时，编译器在引用类所在的同一个包中查找该类声明。

我们可以使用全名来引用一个类如下。

com.w3cschool.Dog aDog;

指定类的访问级别的一般语法是

<access level modifier>class <class name> {
        
        // Body of the class
    }

类声明中`<access level modifier>`只有两个有效值：

*  no value  
    no value被称为包级别访问。具有包级别访问的类只能在声明它的包中访问。
 *  public  
    具有公共访问级别修改器的类可以从应用程序中的任何包访问。

# Java包 #

## Java 导入 ##

导入声明用于将任何类型导入编译单元。

导入声明出现在包声明之后，第一个类型声明之前。

有两种类型的导入声明：

*  单类型导入声明
 *  按需导入声明

1.  **单类型导入声明**  
    用于从包导入单个类型。
    
        import com.w3cschool.Dog;
    
    单类型的导入声明只从包中导入一个类型（一个类）。
    
    要从包中导入多个类型，请为每个类型使用单独的导入声明。
    
    当编译器在语句中遇到Dog类的简单名称时，就像
    
        Dog  jack;
    
    > 编译器将通过所有导入声明将简单名称解析为完全限定名称。  
    > 当它尝试解析简单名称Dog时，它会找到导入声明import com.java2s.Dog，它将导入Dog类。  
    > 它假定您打算在上面的语句中使用简单名称Dog时使用com.java2s.Dog类。
    
    编译器用以下语句替换上面的语句：
    
        com.w3cschool.Dog jack;
    
    导入声明允许您在代码中使用类型的简单名称，从而使您的代码更具可读性。
    
    当编译代码时，编译器用其完全限定名替换类型的简单名称。
    
    它使用导入声明将类型的简单名称转换为其完全限定名称。

**2. 按需导入声明**  
按需导入声明使用一个导入声明从包**导入多个类型**。

按需导入声明的语法是

import <package name>.*;

例如，以下需要的import-on-demand声明从com.java2s包导入所有类型：

import com.w3cschool.*;

#### 静态导入声明 ####

静态导入声明将类型的静态成员（变量/方法）导入到编译单元中。

静态导入声明有两种风格：

*  单静态导入
 *  静态 - 按需导入

1.  **单静态导入声明**从类型中导入一个静态成员。静态导入请求声明导入类型的所有静态成员。
    
    静态导入声明的一般语法如下：
    
        import static <package  name>.<type name>.<static member name>;
2.  **静态导入需求声明**:
    
        import static <package  name>>.<type  name>.*;
    
    System是java.lang包中的一个类，它有一个名为out的静态变量。  
    当你使用System.out时，我们指的是System类中的静态变量。  
    我们可以使用静态导入声明从System类导入out静态变量，如下所示：
    
        import static  java.lang.System.out;
        
        public class  StaticImportTest  {
              
            public static  void  main(String[]  args)  {
              
                out.println("Hello static  import!");
            }
        }
    
    java.lang包中的Math类有许多实用程序常量和静态方法。
    
    例如，它有一个类变量名为PI。
    
    要使用Math类的任何静态变量或方法，我们需要使用类名Math来限定它们。
    
    例如，您可以将PI静态变量称为Math.PI，将sqrt()方法称为Math.sqrt()。
    
    我们可以使用以下static-import-on-demand声明来导入Math类的所有静态成员：
    
        import static  java.lang.Math.*;
    
    例子  
    以下代码通过导入其静态成员来演示使用Math类。
    
        import static java.lang.Math.PI;
        import static java.lang.Math.sqrt;
        import static java.lang.System.out;
        
        public class Main {
              
          public static void main(String[] args) {
              
            double radius = 6.9;
            double area = PI * radius * radius;
        
            out.println("Value of  PI  is: " + PI);
            out.println("Radius of  circle: " + radius);
            out.println("Area of  circle: " + area);
            out.println("Square root of  2.0: " + sqrt(2.0));
          }
        }
    
    以下是关于静态导入声明的一些重要规则。
    
     *  如果导入具有相同简单名称的两个静态成员，一个使用单静态导入声明，另一个使用静态import-on-demand声明，则使用单静态import声明导入的静态成员优先。
     *  使用单静态导入声明来导入具有相同简单名称的两个静态成员是不允许的。
     *  如果使用单静态导入声明导入静态成员，并且在同一类中存在具有相同名称的静态成员，则使用类中的静态成员。

参考：w3cschool