Java 匿名对象 内部类 包的声明与访问 访问修饰符

匿名对象：

匿名对象创建

匿名对象调用方法

package com.oracle.demo01;

public class test {
        public static void main(String[] args) {
            //匿名对象创建
            new  person();
            //匿名对象调用方法
            new person().eat();
            //注意这里的new person()和上面的new person()不是一个，切记        
        }        
}

匿名对象可以作为方法接收的参数使用

匿名对象可以作为方法方法返回值使用

package com.oracle.demo01;

public class person {
     public  void  eat(){
         System.out.println("吃饭");
     }
     //匿名对象可以作为方法方法返回值使用
     public  person name(){
         /* person  p  =  new person();
          return  p;*/
         return  new person();
     }
    //匿名对象可以作为方法接收的参数使用
     public  void  test(){
         ceshi(new person());
         System.out.println("..");
     }
     public void  ceshi(person p){
         System.out.println("1111");
     }
}

内部类：

成员内部类

创建成员内部类对象

成员内部类对象调用方法

package com.oracle.demo02;

public class test {

    public static void main(String[] args) {
        //创建成员内部类对象
        outer.name    na = new  outer().new name();
        //成员内部类对象调用方法
        na.eat();
        na.get();
    }
}

具体取值：

package com.oracle.demo02;
//外部类
public class outer {
            int i = 1;
         //成员内部类  处于成员位置
        class   name{
            int i = 2;
            public  void  eat(){        
                System.out.println("吃饭");
            }
            public void  get(){
                int   i = 3;
                System.out.println(i);            //3  取到成员内部类中的局部变量
                System.out.println(this.i);            //2  取到成员内部类中的成员变量
                System.out.println(outer.this.i);           //1  取到外部类中的成员变量
            }
        }                  
}

局部内部类：

利用外部类对象访问局部内部类方法

package com.oracle.demo02;

public class test2 {
        public static void main(String[] args) {
            //创建外部类对象
              outer2  o = new outer2();
              //利用外部类对象访问局部内部类方法
              o.name();
        }
}

在外部类的成员方法中创建局部内部类对象

package com.oracle.demo02;
//外部类
public class outer2 {
       public  void    name(){
           //局部内部类  处于局部变量的位置
           class  Inter{
               public  void eat(){
                   System.out.println("吃饭");
               }
           }
           //在外部类的成员方法中创建局部内部类对象
           Inter i = new  Inter();
           //局部内部类对象调用方法
           i.eat();
       }
}

匿名内部类：

创建人  类

package com.oracle.demo05;

public abstract class person {
         private   String  name;
         private   int  age;
         public  abstract  void eat();
        public person() {
            super();
        }
        public person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
         
}

创建匿名内部类；

匿名内部类调用方法；

package com.oracle.demo05;

public class test {

    public static void main(String[] args) {
          //匿名内部类
        /*new 父类或接口(){
            //进行方法重写
        };*/
           new   person(){
               public  void eat(){
                   System.out.println("第一个人吃饭");
               }
           };
           //匿名内部类调用方法
           new   person(){
               public  void eat(){
                   System.out.println("第二个人吃饭");
               }
           }.eat();;
    }
}

包的声明和访问：

java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。

声明：  通常将公司网址反写

package 包名.包名.包名…;    //包的声明，必须在有效代码的第一行
//导包

访问：必须使用含有包名的类全名（包名.类名）

//包名.包名….类名
     java.util.Scanner
     java.util.Random
     com.oracle.Demo
//带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
     com.oracle.Demo d = new com.oracle.Demo();

import导包:

导包的格式：

import 包名.类名;

访问修饰符：

 

举个例子：

package com.oracle.demo06;

public class A {
            //public
            public int  a = 1;
            //private 
            private  int  b = 2;
            //default
            int   c = 3;   //注意默认访问修饰符千万别写在前面 
            //protected
            protected  int  d = 4;
            //同一个包中同一个类    都可以访问到
            public  void  ceshi(){
                System.out.println(a);
                System.out.println(b);
                System.out.println(c);
                System.out.println(d);
            }
}

package com.oracle.demo06;

public class B {
    public static void main(String[] args) {
　　　　//同一个包子类与无关类
        A   aa  =  new A();
        System.out.println(aa.a);
        //System.out.println(aa.b);//private 修饰的b访问不到
        System.out.println(aa.c);
        System.out.println(aa.d);
    }
}

package com.oracle.demo07;

import com.oracle.demo06.A;

public class C {
    public static void main(String[] args) {
        //不同包无关类
        A   aa  =  new A();
        System.out.println(aa.a);
        //System.out.println(aa.b);//private 修饰的b访问不到
        //System.out.println(aa.c);//default  修饰的c访问不到
        //System.out.println(aa.d);//protected 修饰的d访问不到
    }
}

package com.oracle.demo07;

import com.oracle.demo06.A;

public class D extends A{
    public static void main(String[] args) {
        D  dd  = new  D();
        System.out.println(dd.a);
        //System.out.println(dd.b);  private 修饰的b访问不到
        //System.out.println(dd.c);  default  修饰的c访问不到
        System.out.println(dd.d);
    }
}

 代码块：

静态代码块和构造代码块：

举个例子：

package com.oracle.demo03;

public class person {
            //静态代码块
            static{
                System.out.println("这是静态代码块");
            }
            public person(){
                System.out.println("这是构造方法");
            }
            {
                System.out.println("这是构造代码块");
            }
} 

package com.oracle.demo03;

public class test {
     public static void main(String[] args) {
         person  p = new person();
            person  p1 = new person();
    }    
}

效果如下：

静态代码块优先于构造代码块优先于构造方法，

另外静态代码块只调用一次