GVKun编程网logo

java package和import的理解（java中package和import）

22

以上就是给各位分享javapackage和import的理解，其中也会对java中package和import进行解释，同时本文还将给你拓展1.7（java学习笔记）package和import、1.

以上就是给各位分享java package和import的理解，其中也会对java中package和import进行解释，同时本文还将给你拓展1.7（java学习笔记）package和import、1.9Java面向对象【this，package，import关键词与mvc设计模式】、13.JAVA-包package、import使用、cannot import name ''PackageFinder''等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

java package和import的理解（java中package和import）

java package和import的理解（java中package和import）

1、java中package是什么

即包。简单地说，它是分类class(类)与interface(接口)的方式。 
在Java开发中，将会写数以百计的类和接口，因此，对它们分类是必须的。 

2、java中import有什么用

在java中，编译器是根据包名+类名找到类的，而import语句是告诉编译器找到指定的类。 
例如，要求编译器来加载所有目录中java安装/java/io可用的类：

<code><span><span>import</span> java.io.*;</span></code><ul><li>1</li></ul><ul><li>1</li></ul>

3、源文件中如何声明的规则

在源文件中，声明类、声明包和写import语句时，有些规则是必不可少的。

  1. 在每一个源文件中只能有一个public类。
  2. 源文件可以有多个非public类。
  3. public类名应该是源文件，以及应当以.java扩展名结尾。例如：类名是- public class Employee{}将源文件应为Employee.java。
  4. 如果类在包中定义，那么package语句应该是源文件中的第一条语句。
  5. 如果import语句都存在，那么它们必须写package语句和类声明之间。如果没有包（package）语句，那么import语句应该是源文件中的第一行。
  6. import和package语句是针对源文件中的所有类。不同的import或package语句不能在同一个源文件中。
  7. 类有四个访问级别，且有不同的类型，如抽象类，final类等（使用修饰符表示）。java修饰符看这里：public、privite、protected有什么区别
  8. 除了上述类型的类，java中还有内部类、匿名类等。

4、java源文件如何编写

首先打开记事本，创建两个类：Employee和EmployeeTest，保存为名称为Employee.java、EmployeeTest.java，这就是java源文件。 
这里Employee类和EmployeeTest类是公共类。 
其中，Employee类有一个明确的构造函数，它接受一个参数。且有四个实例变量的名字，年龄，名称和工资。

<code>import java.io.*;
<span>public</span> <span>class</span> Employee{
   String name;
   <span>int</span> age;
   String designation;
   <span>double</span> salary;

   <span>// This is the constructor of the class Employee</span>
   <span>public</span> <span>Employee</span>(String name){
      <span>this</span>.name = name;
   }
   <span>// Assign the age of the Employee  to the variable age.</span>
   <span>public</span> <span>void</span> <span>empAge</span>(<span>int</span> empAge){
      age =  empAge;
   }
   <span>/* Assign the designation to the variable designation.*/</span>
   <span>public</span> <span>void</span> <span>empDesignation</span>(String empDesig){
      designation = empDesig;
   }
   <span>/* Assign the salary to the variable        salary.*/</span>
   <span>public</span> <span>void</span> <span>empSalary</span>(<span>double</span> empSalary){
      salary = empSalary;
   }
   <span>/* Print the Employee details */</span>
   <span>public</span> <span>void</span> <span>printEmployee</span>(){
      System.<span>out</span>.println(<span>"Name:"</span>+ name );
      System.<span>out</span>.println(<span>"Age:"</span> + age );
      System.<span>out</span>.println(<span>"Designation:"</span> + designation );
      System.<span>out</span>.println(<span>"Salary:"</span> + salary);
   }
}</code><ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li></ul><ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li></ul>

下面给出的是EmployeeTest类，它创建了Employee类的两个实例对象，并调用方法为每个对象中的属性赋值。 
其中有一个特殊方法：main方法。运行类实际上是执行该类的main方法（没有main方法的类不能运行）。

<code>import java.io.*;
<span>public</span> <span>class</span> EmployeeTest{

   <span>public</span> <span>static</span> <span>void</span> <span>main</span>(String args[]){
      <span>/* Create two objects using constructor */</span>
      Employee empOne = <span>new</span> Employee(<span>"James Smith"</span>);
      Employee empTwo = <span>new</span> Employee(<span>"Mary Anne"</span>);

      <span>// Invoking methods for each object created</span>
      empOne.empAge(<span>26</span>);
      empOne.empDesignation(<span>"Senior Software Engineer"</span>);
      empOne.empSalary(<span>1000</span>);
      empOne.printEmployee();

      empTwo.empAge(<span>21</span>);
      empTwo.empDesignation(<span>"Software Engineer"</span>);
      empTwo.empSalary(<span>500</span>);
      empTwo.printEmployee();
   }
}</code><ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li></ul><ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li></ul>

现在，编译这两个类，然后运行EmployeeTest（如何编译看这里：如何用记事本编写Java程序）： 
C :> javac Employee.java 
C :> vi EmployeeTest.java 
C :> javac EmployeeTest.java 
C :> java EmployeeTest

执行结果如下： 
Name:James Smith 
Age:26 
Designation:Senior Software Engineer 
Salary:1000.0 
Name:Mary Anne 
Age:21 
Designation:Software Engineer 
Salary:500.0

1.7（java学习笔记）package和import

1.7（java学习笔记）package和import

package

package主要用于管理类，在java中同一个包下不能有相同的类名，可有时项目总会出现很多同名的类，这时就需要通过包来管理类。不同的包下可以有相同的类名。

包就有点类似于文件夹，不同文件夹中可以有相同的文件名，一个文件夹下不能有同名的文件。

包的命名规则一般是域名倒着写，后面再加具体项目名称。

例如京东的就是 cn.jd.123

 

例如下面位于包cn.hcf.pro3下的TestExtends.java文件和位于包cn.hcf.TestThis包下的TestPackage.java文件中都有Person类，但他们处于不同的包中是可以的。

但当它们位于同一个包下时是不可以的。

 

2.import

import可以导入其他包的类，但这个类必须是以public修饰的（这个知识点还需要学习后面的访问控制才知道为什么）。

 

例如下面我在cn.hcf.oo包下的TestEqu中要用TestPackage包下的TestPackage类，就需要用import导入。

如果不导入，在一个包中使用其它包的类，则会出行错误。

 1 package cn.hcf.oo;
 2 
 3 
 4 import TestPackage.*; //包后面加*就代表导入TestPackage包中的所有类，也可以单独导入包中的一个类，
 5                       //import TestPackage.TestPackage 就代表导入TestPackage包中TestPackage类。
 6 public class TestEqu {
 7     public static void main(String[] args){
 8         TestPackage n = new TestPackage();
 9         
10     }
11 }

 

导入还有静态属性的导入，比如在java.lang包下的Math类中有PI（圆周率）这个静态属性。我们使用要这样写，Math.PI,代表使用PI。

我们可以用静态属性的导入， import static java.lang.math.PI;就导入了PI这个静态属性，导入后可以直接写PI，因为该属性已被导入。

 

还有一个问题，导入时例如我们要使用Date类，在cn.test.1这个包和cn.test.2这两个包中都有Date类，我们导入时这样写

import cn.test.1.Date;

import cn.test.2.*;

那么我们用new = Date()新建一个对象时，优先选择具体导入的类，就是说此时的Date是cn.test.1包中Date；

 

如果我们既要使用cn.test.1中的Date,也要使用cn.test.2中的cn.test.2中的Date时

即使使用 import导入也会出现错误，因为创建Date时无法识别到底是哪一个包中的Date

这时我们需要写出Date具体的路径。

例如我们两个都要使用时：

cn.test.1.Date D1 = new cn.test.1.Date();

cn.test.2.Date D2 = new  cn.test.2.Date();

 

1.9Java面向对象【this，package，import关键词与mvc设计模式】

1.9Java面向对象【this，package，import关键词与mvc设计模式】

this，package，import关键词

this关键字

1.this关键字可以理解为当前对象或者当前正在构建的对象（防止与形参重名）

2.this可以用来修饰属性方法或者调用构造器

public class Teacher {
    private int id; //教师工号
    private String name; //教师姓名
    private int age; //教师年龄

    public Teacher() {
        System.out.println("无参构造器");
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id; //防止与形参重名 
    }

    public Teacher(int id, String name, int age) {
        this();//调用无参构造器
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

package关键字

1.为了实现项目中的类的管理

2.声明在源文件的首行

3.  “.”代表一层目录结构

4.同一个包下无法命名相同名称的类或者接口

 

import关键字

1.引入相关包下面的类

2.声明在package下面

 

mvc设计模式

model：模型层(model.dao数据库操作类，model.domain数据封装类)

view：视图层

controller：控制层（处理业务逻辑）

13.JAVA-包package、import使用

13.JAVA-包package、import使用

1.包的定义

之前我们学习java时,生成的class文件都是位于当前目录中,假如出现了同名文件,则会出现文件覆盖问题,因此就需要设置不同的目录(定义包),来解决同名文件冲突问题.

并且在大型项目中,更加需要模块化,将不同的模块保存在不同的包里,然后编译时再进行一起执行.这样的代码将更易于维护,并且支持多人开发.

 

其实在大型项目里,不同的包里也经常出现同名文件

比如:Linux内核的arch目录下就定义了很多不同cpu处理器相关的子目录,然后又在具体的某个cpu子目录里又有许多不同板卡配置相关的子目录,并且在每个不同板卡子目录里都有个board.h(里面根据不同板卡的硬件定义,来配置不同的引脚信息) .

 

2.package定义包的使用

在java中可以通过package关键字来定义包(也就是目录路径),该语句需要写在文件首行.

定义一个包:

package common.demo ;               //指定生成的class文件位于common/demo/目录下

public class Test
{ 
         public static void main(String args[]){
                  System.out.println("Hello World");
         }
}

代码里出现了package定义后,我们打包编译时,则必须制定路径才行,打包编译方式有以下两种:

javac  -d  . Test.java                                
//"-d ."表示生成的包位于当前路径,所以会在当前路径下自动创建common/demo/目录,然后再在该目录下生成Test .class

 
javac  -d  .  *.java                          
//如果当前目录有多个java文件,并且互相引用的时候,则用这个命令,*表示编译所有java文件.

生成的class路径如下图所示:

 

当我们通过java命令来运行上面class包文件时,直接在编译位置输入包名+类名:

java common.demo.Test                                  

运行如下:

 

 

3.import导入包的使用

之前我们学习了使用package包可以将编译出来的class进行分开保存,那么如果想不同包之间互相调用,则需要使用import关键字来声明包的入口位置.

3.1 import使用

示例1-调用之前生成的common.demo.Test类(位于./common/demo)

定义一个CallTest.java文件:

import common.demo.Test;  //声明Test包类的位置,等价于import common.demo.*;

public class CallTest
{ 
             public static void main(String args[]){
                  Test.main(args);                //调用Test类的公共静态方法
         }
}

编译运行:

 

PS: import声明包的时候,也可以直接使用"包名+*"来声明包里的所有class类.所以"import common.demo.Test;"等价于"import common.demo.*; ",当然这两者的导入性能都是一样的,在运行时,没有使用的包类则不会被加载.

 

3.2 如果未使用import声明的话,在代码里也可以直接通过包名.类来实现访问

示例2-修改CallTest.java,不使用import

//import common.demo.Test;        //屏蔽import
public class CallTest
{ 
             public static void main(String args[]){
                  common.demo.Test.main(args);             //调用common.demo包里Test类的公共静态方法
         }
}

从上面代码可以看出,这样写会显得麻烦. 并且文件开头没有import声明,如果代码量多,则非常不方便查找到包类.

 

3.3 import和package同时使用

如果一个程序package定义了包,并且还需要通过import导入其它包时, 则package必须写在程序句首,然后import写在package之后.

示例3- import和package同时使用,并且调用common.demo.Test类

修改CallTest.java文件:

package call;               //指定生成的class文件位于call目录下
import common.demo.*;       //声明common.demo包

public class CallTest
{ 
         public static void main(String args[]){
                  Test.main(args);                //调用Test类的公共静态方法
         }
}

编译运行:

 

 

 

3.4 import导入多个包里的相同类时

假如我们导入两个包,该两个包分别为article.table(桌子)和article.bed(床).

并且该两个包里都有个相同类Property类,桌子的Property类用标记桌子可以用来办公,吃饭等,而床的Property类则用来标记床可以睡觉.

由于两个包的Property类名都相同,则应该使用完整名称:

import article.table.*;    
import article.bed.*;

public class CallTest
{ 

         public static void main(String args[]){
                  article.table.Property  obj1 = new article.table.Property();  //实例化一个桌子属性类
                  article.bed.Property  obj1 = new article.bed.Property();    //实例化一个床属性类

                  System.out.println(obj1.toString());               //打印桌子的属性
                  System.out.println(obj2.toString());               //打印床的属性
         }
}

 

4.常见的系统包介绍

在java中,除了我们自定义包外,java本身还提供了许多常用的系统包,如下表所示:

包名

作用

Java.lang

Language的缩写,包含了基本数据类型以及包装类,String类,线程类等,该包由系统默认加载(import).

Java.lang,reflect

反射对象包, 该包里提供关于类和对象反射信息的工具,在后续章节学习

Java.util

工具包,提供日期Date类、堆栈Stack类、向量Vector类,链表LinkList类, 随机数Random类等

 

Java.util.regex

正则工具包,用来匹配字符串

Java.text

处理文本包,用来格式化日期、数字和消息，分析，搜索和排序字符串，以及迭代字符、单词、语句和换行符等

Java.io

数据流包,处理文件读写、标准设备输出等

Java.net

网络编程包,里面包含了Socket 类(TCP客户端，用于连接远程主机)

ServerSocket类(TCP服务端，用来接受客户端套接字的连接)

DatagramSocket类(UDP 端点，用于发送和接收数据包)

MulticastSocket 类(是 DatagramSocket 的子类，用来处理广播)

Java.sql

数据库操作包,提供了与各种数据库操作的工具

 

 

未完待续

 

 

cannot import name ''PackageFinder''

cannot import name ''PackageFinder''

在这里插入图片描述

python get-pip.py

解决问题

我们今天的关于java package和import的理解和java中package和import的分享已经告一段落，感谢您的关注，如果您想了解更多关于1.7（java学习笔记）package和import、1.9Java面向对象【this，package，import关键词与mvc设计模式】、13.JAVA-包package、import使用、cannot import name ''PackageFinder''的相关信息，请在本站查询。

本文标签：

上一篇在Python中打印简单的菱形图案（在python中打印简单的菱形图案）

下一篇关于返回 Null 值的问题（返回值为null）

相关文章