myeclipse-10创建项目 包 类

File---->new---->java project


点击Finish
创建Java项目



右击,new下package


点击Finish


点击包，new下class

1.编译运行含有包层的类
 
java中，为了确保类名的唯一性，以及方便组织自己的代码，引入了包package。
package语句必须放在程序代码的第一行，除注释之外。
在某一程序代码的首行，如果没有package语句，代码仍然可以编译，编译后的class文件被存放在默认包中，即与java文件同目录。
《JAVA编程思想》中这样写到：“Java将这样的文件自动看作是隶属于该目录的默认包之中，于是它们为该目录的其他文件都提供了包访问权限。”即该默认包中的其他文件是可以访问这些文件（“这样的文件”）的。
提供一个例子，如何编译和运行含有包层的类：
 
package com.access;

class PrintString
{
    void print()
    {
        System.out.println("Hello World!");
    }
}
public class TestPackage 
{
    public static void main(String[] args) 
    {
        PrintString ps = new PrintString();
        ps.print();
    }
}
 
编译：javac -d . TestPackage.java 其中：-d表示自动生成包层 . 表示这个包层是在当前目录下建立。
运行：java com.access.TestPackage
输出：Hello World! 
 
注意： 
 （1）package com.access; 表示把该文件的所有的类放入com.access这个包中，并且该文件所有类的真正名字将是包名和类名的组合。例如，类TestPackage 的名字将编程com.access.TestPackage ，而不再是TestPackage 。 
 （2）编译时建议使用：javac -d . TestPackage.java 尽量不要使用javac TestPackage.java 因为后者要手动的建立包目录。 
 （3）如果不再当前路径下运行程序，则必须保证class文件的最上层目录的父目录位于classpath下。
例如：包的父目录是D:\JavaProject\demo12。现在要在C:\Users\Administrator目录下运行TestPackage。实现步骤如下： 
 （1）设置环境变量：C:\Users\Administrator> set classpath=d:\JavaProject\demo12;注意：classpath=d:\JavaProject\demo12这部分没有空格。 
 （2）运行：C:\Users\Administrator> java com.access.TestPackage 
 
注意： 
 （a）classpath：设置的是可运行的class文件的路径。在任何路径下都可以导入包中的类，此时就需要设置classpath， 
 classpath：即设置的导入的类的路径 
 （b）set classpath：查看当前环境变量classpath的设置 
 （c）设置路径：set classpath=导入类文件的包的父目录; //不要把包层的目录放进去 
 （d）java access.ChocolateChip2解析： 先检测当前目录下是否有access这个包（包即文件夹），如果有，再检测该包下是否有access.ChocolateChip2这个类；如果没有，编译器将再去classpath设置的路径中依次查找是否有access这个包（包即文件夹），如果有，再检测该包下是否有access.ChocolateChip2这个类。如果都查找失败，则运行出错。
 
2.同包和不同包类的相互访问
 
1.同包类的相互访问
 
一个类可以使用所属包中的所有类，以及其他包中的共有类（public class）。即只有公有类才能被另外一个包访问。
在同一个包中，可以相互访问具有包权限的类和成员。具有包权限的类，即使其成员是公有的，也不能被其他包所访问。具体请见：JAVA——java中类的public class与class的区别详解
 
2.不同包类的相互访问
 
访问方式一：不使用import语句
在“编译运行含有包层的类”这一节中讲到，将类放入包中，类的真正的名字就变为：包名和类名的组合。
 
package access.cookie2;

public class Cookie
{
    public Cookie()
    {
        System.out.println("Cookie constructor");
    }
    public void bite()
    {
        System.out.println("bite");
    }
}  
 
package access;

public class ChocolateChip2
{
    public ChocolateChip2()
    {
        System.out.println("ChocolateChip2 constructor");
    }

    public static void main(String[] args)
    {
        ChocolateChip2 x = new ChocolateChip2();

        access.cookie2.Cookie y = new access.cookie2.Cookie();//包名和类名的组合，要使用Cookie类，就必须冠以全名。
        y.bite();       
    }
}
 
编译、运行：
 
D:\JavaProject\demo11>javac -d . Cookie.java ChocolateChip2.java

D:\JavaProject\demo11>java access.ChocolateChip2
ChocolateChip2 constructor
Cookie constructor
bite
 
访问方式二：使用import语句
import：即类的导入方法，import语句是一种引用包含在包中的类的简明描述。access.cookie2.Cookie y = new access.cookie2.Cookie();这个写法很不简洁。一旦使用了import语句，在使用类时，就不必写出包的全名了。
可以使用import语句导入一个特定的类或整个包。例如：import java.util.*;导入java.util包中所有的类。import java.util.Date;导入java.util包中Date这一特定类。
import语句应该位于源文件的顶部，但是位于package语句的后面。
只能使用*导入一个包，而不能使用import java.*或import.java.*.*导入一个一java为前缀的所有包。
 
package access.cookie2;

public class Cookie
{
    public Cookie()
    {
        System.out.println("Cookie constructor");
    }
    public void bite()
    {
        System.out.println("bite");
    }
}  
 
package access;
import access.cookie2.*;

public class ChocolateChip2
{
    public ChocolateChip2()
    {
        System.out.println("ChocolateChip2 constructor");
    }

    public static void main(String[] args)
    {
        ChocolateChip2 x = new ChocolateChip2();

        Cookie y = new Cookie();
        y.bite();       
    }
}
 
3.不同包子类和父类的访问权限：protected 继承访问权限
 
对于默认访问权限（包访问权限）的类，可以被这个包中的其他类访问；
对于继承了具有包访问权限的成员的类的子类，如果该子类和父类唯一同一个包中，子类可以访问父类中的默认访问控制成员。
 
package access.cookie2;

public class Cookie
{
    public Cookie()
    {
        System.out.println("Cookie constructor");
    }
    void bite()
    {
        System.out.println("bite");
    }
}  
 
package access;
import access.cookie2.*;

public class ChocolateChip2 extends Cookie
{
    public ChocolateChip2()
    {
        System.out.println("ChocolateChip2 constructor");
    }
    public void chomp()
    {
        bite();
    }

    public static void main(String[] args)
    {
        ChocolateChip2 x = new ChocolateChip2();
        x.chomp();
    }
}
 
编译、运行：
 
D:\JavaProject\demo11>javac -d . Cookie.java ChocolateChip2.java
ChocolateChip2.java:13: 错误: 找不到符号
                bite();
                ^
  符号:   方法 bite()
  位置: 类 ChocolateChip2
1 个错误
 
由于子类和父类不在同一个包中，且方法bite()具有包访问权限，因此子类是访问不到成员bite()的，故编译错误。
将做如下改进：
 
package access.cookie2;

public class Cookie
{
    public Cookie()
    {
        System.out.println("Cookie constructor");
    }
    protected void bite()
    {
        System.out.println("bite");
    }
}  
 
编译、运行：
 
D:\JavaProject\demo11>javac -d . Cookie.java ChocolateChip2.java

D:\JavaProject\demo11>java access.ChocolateChip2
Cookie constructor
ChocolateChip2 constructor
bite
 
原因：protected修饰的成员方法，可以被同一个包的其他类访问，同时也能被不同包中的子类访问。但是对于其他包中的类而言，却是private的。
以上是针对方法bite()没有重写的情况而言的。如果在子类对bite()进行了重写，以上的问题就不会存在了。说明子类访问的本类重写以后的方法bite，而不是父类的方法bite。
验证protected修饰的成员，不在同一个包，不存在继承时，对于其他包中的类而言，却是private的。
 
package access.cookie2;

public class Cookie
{
    public Cookie()
    {
        System.out.println("Cookie constructor");
    }
    protected void bite()
    {
        System.out.println("bite");
    }
}
 
package access;
import access.cookie2.*;

public class ChocolateChip2
{
    public ChocolateChip2()
    {
        System.out.println("ChocolateChip2 constructor");
    }

    public static void main(String[] args)
    {
        ChocolateChip2 x = new ChocolateChip2();

        Cookie y = new Cookie();
        y.bite();       
    }
}
 
编译、运行：
 
D:\JavaProject\demo11>javac -d . Cookie.java ChocolateChip2.java
ChocolateChip2.java:48: 错误: bite()可以在Cookie中访问protected
                y.bite();
                 ^
1 个错误

包命名规范：

 
目的：包的命名规范应当体现出项目资源良好的划分

 

 

 
servlet类所在包命名规范：公司名称.开发组名称.项目名称.web.servlet

 
例如：net.linkcn.web.servlet

 

 

 
自定义标签类所在包命名规范：公司名称.开发组名称.项目名称.web.tags

 
例如：net.linkcn.web.tags

 

 

 
过滤器类所在包命名规范：公司名称.开发组名称.项目名称.web.filter

 
例如：net.linkcn.web.filter

 

 

 
Action类所在包命名规范：公司名称.开发组名称.项目名称.web.struts.action

 
例如：net.linkcn.web.struts.action

 

 

 
ActionForm类所在包命名规范：公司名称.开发组名称.项目名称.web.struts.form

 
例如：net.linkcn.web.struts.form

 

 

 
Javabean所在包命名规范：公司名称.开发组名称.项目名称.web.struts.service.impl

 
例如：net.linkcn.web.service.impl

 

 

 
Javabean实现接口命名规范：公司名称.开发组名称.项目名称.web.service

 
例如：net.linkcn.web.service

 

 

 
DAO类所在包命名规范：公司名称.开发组名称.项目名称.dao.impl

 
例如：net.linkcn.dao.impl

 

 

 
DAO类所实现的接口在包中命名规范：公司名称.开发组名称.项目名称.dao

 
例如：net.linkcn.dao

 

 

 
POJO类与hbm文件所在包命名规范：公司名称.开发组名称.项目名称.dao.hbm

 
例如：net.linkcn.dao.hbm

 

 

 
全局公共类、接口类所在包命名规范：公司名称.开发组名称.项目名称.global

 
例如：net.linkcn.global

 

 

 
全局工具类所在包命名规范：公司名称.开发组名称.项目名称.util

 
例如：net.linkcn.util

 

 

 
类命名规范

 
基本命名规范：

 

 

 
类、接口命名

 
命名规范：以大写字母开头，如果有多个单词，每个单词头字母大写

 
例如：StudentInfo

 

 

 
接口命名

 
命名规范：以大写字母"I"开头，如果有多个单词，每个单词头字母大写

 
例如：IStudentInfo

 

 

 
接口实现类命名：

 
命名规范：将实现的接口名称的首字母"I"去掉，以"Impl作为结尾"，如果有多个单词，每个单词头字母大写。

 
例如：StudentInfoImpl

 

 

 
J2EE+SSH框架命名规范

 

 

 
servlet类命名：

 
命名规范：以Servlet单词结尾

 
例如：LoginServlet

 

 

 
POJO命名：

 
使用hibernate自动生成的类即可

 

 

 
DAO类命名：

 
使用hibernate自动生成的类即可

 

 

 
Action类命名：

 
命名规范：Action的命名以POJO名称来制定，POJO名称Action

 
例如：

 
一个POJO名称为Diary，其对应的action为DiaryAction

 

 

 
ActionForm类命名：

 
命名规范：ActionForm的命名以POJO名称来制定，POJO名称Form

 
例如：

 
一个POJO名称为Diary，其对应的actioForm为DiaryForm

 

 

 
业务逻辑接口命名:

 
命名规范：业务逻辑接口的命名以POJO名称来制定，IPOJO名称Service

 
例如：

 
一个POJO名称为Diary，其对应的业务逻辑接口为IDiaryService

 

 

 
业务逻辑实现类命名:

 
命名规范：业务逻辑接口实现类的命名以POJO名称来制定

 
例如：

 
一个POJO名称为Diary，对应的业务逻辑接口实现类名为DiaryServiceImpl

如果引用第三方jar包，肯定是不能直接使用常用注解@Controller、@Service、@Repository、@Component将类的实例注入到spring容器中。以下四种方法可以向spring容器中导入三方包中类实例 。
 
1 xml配置
 
这种情况大家用的比较多，就是在spring的xml文件中配置需要导入的bean。在springweb项目工程web.xml中 ContextLoaderListener或者DispatcherServlet的初始参数contextConfigLocation指定spring配置文件位置，可以在该配置文件中直接定义bean，或者在该配置文件中import专门配置三方bean的xml文件。springboot工程，可以在启动类上面加注解@ImportResource。@ImportResource注解可以通过value指定需要扫描的xml文件，value是字符串数组可以指定多个xml配置文件。
 
@SpringBootApplication
@ImportResource(value = {"classpath:spring-bean.xml"})
public class DubboOneApplication {

    public static void main(String[] args) {
        SpringApplication.run(DubboOneApplication.class, args);
    }
}
 
2 @Configuration和@Bean
 
可以通过直接直接向spring容器注入bean。在开启注解扫描的情况下，在扫描的包路径中添加具有@Configuration注解的类，在该类的定义返回某个实例的方法，这个方法加上@Bean的注解，那么这个方法的返回值将注入spring容器，这个bean的名称是这个方法的名称。
 
3 @Import
 
@Import可以直接向容器中导入第三方包中bean。在开启注解扫描的情况下，可以在有@Controller，@Service，@Component，@Repository，@Configuration注解的类上面添加@Import注解，@Import注解有一个类数组类型的属性，类数组中的类有以下四种情况
 
普通的类名称，该类被注入容器，bean名称是全类名
@SpringBootApplication
@Import({TestTwo.class})
public class DubboOneApplication {

    public static void main(String[] args) {
        SpringApplication.run(DubboOneApplication.class, args);
    }
}
 
具有Configuration作用的类，没有@Configuration注解，里面定义了具有@Bean注解的方法，例如上面TestTwo中有一个返回TestThree的方法使用了@Bean注解，那么TestThree也会注入进容器，bean名称就是方法名，和@Configuration注入功能类似。
ImportSelector实现类，该接口具有一个方法，方法的返回值是字符串数组，每一项是全类名，通过参数AnnotationMetadata可以得到这个被@Import注解修饰类的信息。同样这样注入进来的bean的名称也是全类名，可以返回空数组，不可以返回null。第一种直接写注入类名和使用ImportSelector实现类，都没有办法使用注入类的有参构造方法，bean的名称也没有办法指定，不过只单实例自动注入，不用关心bean名称。
public interface ImportSelector {

	/**
	 * Select and return the names of which class(es) should be imported based on
	 * the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
	 */
	String[] selectImports(AnnotationMetadata importingClassMetadata);

}
 
ImportBeanDefinitionRegistrar实现类，该类有个方法可以直接向Application中手动注入bean，我们可以简单定义一个bean然后注入。
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    RootBeanDefinition definition = new RootBeanDefinition(TestFive.class);
    registry.registerBeanDefinition("testTive",definition);
 }
 
4 @FactoryBean
 
FactoryBean可以用来实现代理，原始的代理实现就可以使用ProxyFactoryBean，还有专门用来实现事务代理的TransactionProxyFactoryBean。使用注解和配置的方式和一般bean一样向容器中注入一个FactoryBean的实现类，实际注入的该FactoryBean中getObject方法返回的对象，这个bean的名称还是对应配置或注解中指定的名称。
 
@Component("testFive")
public class TestFour implements FactoryBean<TestFive>{
    @Override
    public boolean isSingleton() {
        return true;
    }

    @Override
    public TestFive getObject() throws Exception {
        return new TestFive();
    }

    @Override
    public Class<?> getObjectType() {
        return TestFive.class;
    }
}