Java学习第十一章 之 final、static、内部类

/*

final修饰的类，变量，方法有什么特点

       被final修饰的类不能被继承，可以继承其他类

       被final修饰的变量不能更改，可以在创建对象前赋值，创建对象前调用构造方法，为变量赋值

       被final修饰的引用类型变量，地址值不能更改，地址中的属性可以改变

       被final修饰的方法，不能被子类重写

       

*/

//定义一个被final修饰的类

public final class Final{

    final int a = 1;

    final int b;

   public Final(){

      b = 2;

 

   public final void work(){}

   }



  public static void main(String[] args){

      Final f = new Final();

     f.name = "张三";

  }

}



/*

static：静态修饰符

           多个对象在访问或修改static修饰的成员变量时，其中一个对象改变了成员变量的值，其他对象的成员变量的值跟着改变，即多个对象共享同一个static修饰的成员变量

           被static修饰的成员可以直接用类名调用，类名.静态成员变量      类名.静态成员方法(参数)

           同一类中，静态成员只能访问静态成员

           静态优先于非静态

           定义静态常量，通常使用public static final 数据类型  变量名 = 值

*/

public class Static{

   public staitc int num = 10;

   public static void main(String[] args){

        Static s = new Static();

        Static s2 = new Static();

        s.num = 111;

        System.out.println(s.num + " " + s2.num);  

  }

}

publi class Demo{



    public int i = 2;

    public static int a = 1;

    public static final String NAME = "李四";

    public  static void method(){

      System.out.println("静态方法");

    }

public  static void main(String[] args){

       System.out.println(i);

       System.out.println(Demo.a);

       System.out.println(Demo.NAME);

       Demo.method();       

}

}



/*

匿名对象

*/

public class Animal{

     　　public Animal eat(){

              return new Animal; //匿名对象可以作为返回值
           }


          public static void method(Person p){

                

            }

    public static void main(String[] args){

                Animal a = new Animal();//普通对象

                new Animal();//匿名对象

                Animal.method(new Person());//匿名对象可以作为方法参数

     }

}

/*

内部类：成员内部类、局部内部类、匿名内部类

*/

//成员内部类

public class Person{

    class Heart{

      public void jump(){

         System.out.println("跳动");

        }

    }

  public static void main(String[] args){

       Person.Heart p = new Person().new Heart();

        p.jump();

    }

}

//局部内部类

public class Animal{

     public void eat(){

          System.out.println("吃");

           class Cat{

            public void run(){

               System.out.println("跑");

             }

         }

       new Cat().run();//创建内部类对象，调用run方法

    }

   public static void main(String[] args){

      Animal a = new Animal();//创建外部类对象

      a.eat(); //调用外部类方法

   }
}

/*匿名内部类

  创建接口

*/

public interface Person{

     public  void eat();

     public void run();

}

public class TestPerson implements Person{

   public static void main(String[] args){

              Person p = new Person(){

                  public void eat(){

                   System.out.println("吃饭");

                 }

                 public void run(){

                   System.out.println("跑步");

                  }

             };

            p.eat();

            p.run();

   }

}



/*

  代码块:静态代码块只执行一次

*/

public class Animal{

     String name;

     {

      System.out.println("构造代码块");

     }

     public Animal(){

         super();

         System.out.println("无参构造代码块");

     }

     public Animal(String name){

              this.name = name;

     }

    static{

        System.out.println("静态代码块");

     }

     public static void main(String[] args){

              Animal a = new Animal();

              Animal a2 = new Animal("张三");

              System.out.println("普通代码块");

     }

}