包

class Person{
Person p=new Person("Steven",25);
System.out.println(p.name);
System.out.println(p.getPersonInfo);


}
}
class Person{
   private String name;
    private int age;
    public void setName(String n){
    name=n;
    }
    public String getName(){
    return name;
    } 
    public void setAge(int i){
    if(i>0&&i<=200){
    age=i;
    }else{
    age=0;
    }
    }
    public int getAge(){
    return age;
    }
 public void getPersonInfo(){
  System.out.println(name,age);
 }
}
public class Test{
public static void main(String[] args){
Person.person=new Person();
Person.setName="haha";
Person.setAge=-200;
Person.getPersonInfo();
}
}


public class Test{
int num;
char character;


}
class Test{
public int a;
public char b;
} 
public Test (int a,char b ){
this.a=a;
this.b=b;
}
public class InteDemo{
 public static void main(String[] args) {
    Test test =new Test();
    System.out.println(test.a);
    System.out.println(test.b);
}
}


public class InteDemo{
public static void main(String[] args){
       int firstName=1;
       int scondName=1;
       int thirdName=0;
       if(i<3){
        System.out.println(firstName,scondName);
       }else
       for(i=0;i<n;i++){
        thirdName=firstName+scondName;
        firstName=scondName;
        scondName=thirdName;
        System.out.println(thirdName);
       }
}
public class InteDemo{
private static int getFibo(int i){
if(i==1||i==2)
return 1;
else
return getFibo(i-1)+getFibo(i-2);
}
public static void main(String[] args){
for(int j=1;j<4;j++) {
System.out.println(getFibo(j));
}
}
}
 class Test{
  int a;
  String b;
  public void wuCan(){
  System.out.println("HelloConstructor");
  } 
  public String chongZai(String b){
  return "HelloConstructor";


  }
 } 
public class InteDemo{
public static void main(String[] args) {
Test.wuCan();
System.out.println(chongZai());
}
}
public class Test{
public static void main(String[] args){
{
int x=10;
System.out.println("x1="+x);
}
int x=10;
System.out.println("x2="+x);
}
}
class Outer{
private String msg="Hello World";
***********************
class Inner{
public void print(){
System.out.println(msg);
}
}
public void fun(){
Inner in=new Inner();
in.print();
}

    public Person(){
    System.out.println("2.person类的构造方法");
    }
    {
System.out.println("1.person类的构造快");
}
static {
System.out.println("3.person类的静态块");
}
}
public class Test{
public static void main(String[] args){
System.out.println("----start----");
new Person();
new Person();
System.out.println("-----end----");


}
static{
System.out.println("4.主类中的静态块");
}
public static void main(String[] args) {
Outer out=new Outer();
out.fun();
}
}
**********************************
class Outer{
private String msg="Hello World";s
public String getMsg(){
return this.msg;
}
public void fun(){
Inner in=new Inner(this);
in.print();
}
}
class Inner{
private Outer out;
public Inner(Outer out){
this.out=out;
}
public void print(){
System.out.println(out.getMsg());
}
}
public class Test{
public static void main(String[] args) {
 Outer out=new Outer();
 out.fun();
}
}
class Person{
private String name;
private int age;

public Person(){
System.out.println("*******产生一个新的Person对象********");
}
public Person(String name){
System.out.println("******产生一个新的Person对象**********");
this.name=name;
}
public Person(String name,int age){
System.out.println("*****产生一个新的Person对象*****");
this.name=name;
this.age=age;
}
}
public String getPersonInfo(){
return "姓名:"+name+",年龄:"+age;
}

public class Test{
public static void main(String[] args) {
Person per1=new Person();
Person per2=new Person("张三");
Person per3=new Person("李四",20);
System.out.println(per1,getPersonInfo());
System.out.println(per2.getPersonInfo());
System.out.println(per3.getPersonInfo());
}
}
包：实际上就是一个文件夹。
一旦程序出现包名称，那么*.class 必须存在相应目录下。在JDK编译的时候使用配置参数。
编译方式 javac -encoding UTF-8 -d . Test.java  按照此种方式完成编译之后发现，自动会在当前目录下生成相应的文件夹以及相应的*.class文件。
一旦程序类上出现了包名称，那么在执行的时候就需要带上包名称，即使用完整类名称“包.类”。java www.bit.java.Test
package www.bit.java;
public class Test{
public static void main(String[] args) {
System.out.println("Hello World");


}
}
包的导入
开发中使用包的定义之后，相当于把一个大的项目分别按照一定要求保存在不同的包之中，但是这些程序类一定会发生互相调用的情况，这个时候就需要包的
导入
从正常的角度来讲，Test类引用了Message类，那么首先编译的应该是
package www.bit.java.util;
public class Message{
public void print(){
System.out.println("[Message]Hello Package");
}
从正常的角度来看，Test类引用了Message类，那么首先编译的应该是Message类，而后才是Test类。
最好的方法是java自己去匹配编译的先后顺序，最常用的打包编译命令为：javac -d ../*.java
注意：类使用class和public class的区别：
1.public class:文件名称必须与类名称保持一致，如果希望一个类被其他包访问，则必须定义为public class.
2.class:文件名称可以与类名称不一致，在*.java中可以定义多个class，但是这个类不允许被其他包所访问
package www.bit.java.test;
import www.bit.java.util.Message;
public class Test{
public static void main(String[] args) {
System.out.println("haha");
Message msg=new Message();
msg.print();
}
}
import只会导入一个类，要导入一个包中的多个类，可以直接采用通配符“*”来完成.import www.bit.java.util.* 这种并不是意味着要将所有类都进行
导入，而是根据你的需求来导入。
package www.bit.java.test;
import www.bit.java.util.*;
import www.bit.java.message.*;
public class Test{
public static void main(String[] args) {


Message msg=new Message();
msg.print();
}
}
访问控制权限
在不同包中，只有子类能访问父类中的protected权限
private<default<protect<public
jar命令(important)
jar本质上也是一种压缩文件，里面保存的都是*.class文件。如下几个参数：
1."c":创建新档案
2."f":指定档案文件名
3."v":在标准输出中生成详细输出
package www.bit.java.test;
public class Test{
public static void main(String[] args) {
System.out.println("Hello Bit");
}
}
单例设计模式：一个类只允许产生一个实例化对象。
package test;
class Singleton{
static Singleton instance=new Singleton();//instance对象（属性）是一个普通属性，所有的普通属性必须在实例化对象的时候才能进行内存空间的分配
//而现在外部无法产生实例化对象所以必须想一个办法，可以在Singleton没有实例化对象产生，也可以将instance进行使用。 static关键字
对于单例设计模式也有两类形式：懒汉式，饿汉式。
懒汉式，不管你是否使用Singleton类的对象，只要该类加载了，那么一定会自动创建好一个公共的instance对象。既然是懒汉式，就希望整体的操作之中只能
够有一个实例化对象。所以一般还会在前面追加一个final关键字。
private Singleton(){


}
public void print(){
System.out.println("Hello world");
}
}
public class SingletonTest{
public static void main(String[] args){
Singleton singleton=null;
singleton=Singleton.instance;
singleton.print();
}
}
一旦构造方法被私有化，表示外部无法调用构造即外部不能够产生新的实例化对象。此时的类是一个相对而言封闭的状态。如果此时还想继续调用
Singleton类的print()方法，那么必须提供实例化对象。考虑到封装的特，可以在类的内部产生一个实例化对象




static关键字
传统属性所具备的特征：保存在堆内存中，且每个对象独享属性
static属性又称为类属性，保存在全局数据区的内存之中，所有对象都可以进行数据区的访问
访问static属性（类属性）应使用类名称.属性名。
所有的非static属性（实例变量）必须在对象实例化后使用，而static 属性（类属性）不受对象实例化控制
使用static定义的方法，直接通过类名称访问，所有的static方法不允许调用非static定义的属性或方法。所有的非static方法允许访问static方法或属性
使用static定义方法只有一个目的：某些方法不希望受到类的控制，即可以在没有实例化对象的时候执行（广泛应用与工具类中）
final关键字
在java中final被称为钟洁器，可以使用final来定义类，方法，属性。
使用final定义的类不能有子类（String类便是使用final定义的），使用final定义的方法不能被子类所覆写，使用final定义的变量是常量，在声明是赋值。
且不能被修改


package test;
class Singleton{
static Singleton instance=new Singleton();//instance对象（属性）是一个普通属性，所有的普通属性必须在实例化对象的时候才能进行内存空间的分配
//而现在外部无法产生实例化对象所以必须想一个办法，可以在Singleton没有实例化对象产生，也可以将instance进行使用。 static关键字
private Singleton(){


}
public static Singleton getInstance(){
return instance;
}
public void print(){
System.out.println("Hello world");
}
}
public class SingletonTest{
public static void main(String[] args){
Singleton singleton=null;
singleton=Singleton.instance;
singleton.print();
}
}
package test;
class Singleton{//在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象
private final static Singleton INSTANCE=new Singleton();
private Singleton(){


}
public static Singleton getInstance(){
    return INSTANCE;
    }
public void print(){
System.out.println("Hello world");
}
}
public class SingletonTest{
public static void main(String[] args){
Singleton singleton=null;
singleton=Singleton.getInstance();
singleton.print();
}
}
面试题：请编写一个单例程序，并说明程序的主要特点。
特点：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象
懒汉式
package test;
class Singleton{//在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象
private final static instance;
private Singleton(){


}
public static Singleton getInstance(){
    return instanc;
    }
public void print(){
System.out.println("Hello world");
}
}
public class SingletonTest{
public static void main(String[] args){
Singleton singleton=null;
singleton=Singleton.getInstance();
singleton.print();
}
}
懒汉式存在多线程安全问题，而饿汉式不会