2019-05-20 Java学习日记 day10

package

将字节（.class）进行分类存放

包就是文件夹

包的注意事项：

　　package语句必须是程序的第一条可执行的代码

　　package语句在一个java文件中只能有一个

　　如果没有package，默认表示无包名

生成包： jabac -d（指当前文件夹） .  文件名.java

运行：java com.heima（包的文件名） 文件名

//第一包
package com.heima;

class demo1_package
{
    public static void main (String args[]){
     com.baidu.person p=new com.baidu.person("吴江德",30);
     System.out.println(p.getname()+","+p.getage());
     
    }
}


//第二个包
package com.baidu;
public class person
{
    private String name;
    private int age;
    public person(){}
    public person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setname(String name){
        this.name=name;
    }
    public String getname(){
        return name;
    }
    public void setage(int age){
        this.age=age;
    }
    public int getage(){
        return age;
    }
}

import

就是让有包的类对调用者课件，不用写全类名

格式：import 包名

//第一个包
package com.heima;
import com.baidu.person;
import java.util.Scanner; //在开发中都是导入具体类
//*代表通配符，他会到该包下挨个匹配，匹配上就导入
class demo1_package
{
    public static void main (String args[]){
     person p=new person("吴江德",30);
     System.out.println(p.getname()+","+p.getage());
     Scanner sc=new Scanner(System.in);
     int x =sc.nextInt();
     System.out.println(x);
    }
}

//第二个包
package com.baidu;
public class person
{
    private String name;
    private int age;
    public person(){}
    public person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setname(String name){
        this.name=name;
    }
    public String getname(){
        return name;
    }
    public void setage(int age){
        this.age=age;
    }
    public int getage(){
        return age;
    }
}

修饰符：

　　权限修饰符：private，默认的，protected，public

　　状态修饰符：statuic，final

　　抽象修饰符：abstract

类：

　　权限修饰符：默认的，public

　　状态修饰符：final

　　抽象修饰符：abstract

成员变量：

　　权限修饰符：private，默认的，protected，public

　　状态修饰符：statuic，final

构造方法：

　　权限修饰符：private，默认的，protected，public

成员方法：

　　权限修饰符：private，默认的，protected，public

　　状态修饰符：statuic，final

　　抽象修饰符：abstract

组合规则：public static final  成员变量

成员方法：　　public  static

　　　　　　　public abstract

　　　　　　　public final

内部类访问特点：

　　内部类可以直接访问外部类的好处能源，包括私有

　　外部类要访问内部类的成员，必须创建对象

　　外部类名.内部类名  对象名 = =外部类对象.内部类对象

class  demo1_innerclass
{
    public static void main (String args []){
       //外部类访问内部类时一定要创建对象
    outer.inner oi=new outer().new inner();
        oi.method();
    }
}
class outer
{
    private int num=20; 
    class inner     //内部类可以直接访问外部类
    {
        public void method(){
        System.out.println(num);
        }
    }
}    

class  demo1_inner
{
    public static void main (String args []){
    //outer.inner oi=new outer().new inner();
    //oi.method();
    outer o=new outer();
    o.print();
    }
}
class outer
{
    private int num=20;
    private class inner
    {
        public void method(){
        System.out.println(num);
        }
    }
    public void print(){
    inner i=new inner();
    i.method();
    }
}

class  demo2_inner
{
    public static void main (String args []){
        //外部类名.内部类名 对象名 = 外部类名.内部类对象
    outer.inner oi=new outer.inner();
    oi.method();

    outer.inner2.print();
    }
}
class outer
{
    
    static class inner{
        public void method(){
        System.out.println("xixi");
        }
    }
    static class inner2{
        public  static void print(){
        System.out.println("print");
        }
    }
}

局部内部类

只能在其所在的方法中访问

class  demo1_innerclass
{
    public static void main (String args []){
    outer o = new outer();
    o.print();
    }
}
class outer
{
    public void print(){
    class inner{
        public void method(){
        System.out.println("xixi");
        }
    }
    inner i = new inner();  
    i.method();
    }
}

局部内部类在访问他所在的方法重的局部变量必须用final修饰

　　因为当调用这个方法时，局部变量如果没有用final修饰，他的生命周期和方法是一样的，当方法弹栈时，这个局部变量也会消失，

那么局部内部类对象还没有马上消失想用这个局部变量，就没有了，如果用了final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也可以进行使用

这个的jdk1.8取消了，不用加final也可以调用

匿名内部类

就是内部类的简化写法

前提：存在在一个类或者接口

　　这里的类视具体类也可以是抽象类

格式

　　new  类名或者接口名（）{

　　　　重写方法：

}