面向对象2

Static关键字

1.属性/静态方法

类变量方法（略）

2.静态代码块

静态代码块随着类加载执行，只执行一次，通常用来初始化一些东西（详见类加载机制）
匿名代码块是创建对象的时候执行，且在构造器调用之前,可用来赋值初始值

public class Person{
      {
            System.out.println("匿名代码块");//输出顺序2
      }
      static{
            System.out.println("静态代码块");//输出顺序1
      }
   public person(){
       System.out.println("构造方法");//输出顺序3
      }
   public static void main (String[] args){
            Person person = new Person();
      }
}

静态导入包

import static .

import static java.lang.Math.random;
public class Test{
      public static void main(String[] args){
            //System.out.println(Math.random());
            //不需要加类名可以直接调用静态的方法和属性
            System.out.println(random());
      }
}

final修饰的类，不能被继承。断子绝孙。。。

抽象类

abstract 修饰类---抽象类
修饰方法---抽象方法，只有方法的名字，没有方法体
抽象类特点

1. 不能new 抽象类，但是又构造器，只能靠子类去实现它
2. 抽象类里可以没有抽象方法，有抽象方法的类一定是抽象类
3. 继承了抽象类的非抽象子类，必须实现它所有的抽象方法
4. 抽象类存在的意义， 提高开发效率

接口

普通类：方法一定有具体的实现
抽象类：具体实现（普通方法）+抽象方法
接口： 只有抽象方法（规范， 约束和实现分离，面向接口编程~
用interface关键字来定义，接口里方法默认是public abstract的

public interface UserService{
      void add(String name);
      void delete(String name);
      void update(String name);
      void query(String name);
}
// 抽象类使用extend，接口使用implements
//通常加Impl命名实现接口的实现类.实现类需要重写接口中的方法
//实现类可以实现多个接口
public class UserServiceImpl implements UserService {
      //接口里常量是public static final的,但是很少在接口里定义常量
      //public static final int AGE = 99;
      void add(String name){
      }
      void delete(String name){
      }
      void update(String name){
      }
      void query(String name){
      }    
}

接口特点
1.方法是public abstract的，如果又属性一定是常量public static final的
2. 接口不是类，没有构造方法，不能被实例化.
3. 实现类implements可以实现多个接口，必须要重写接口中的方法

内部类

在同一个java 文件中写互不包含的多个类，只能有一个类为public的
例.Outer.java

public class Outer{
}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
}

特点

• 编译之后可以生成独立的字节码文件，Outer.class, Outer$Inner.class
• 内部类可以直接访问外部类的属性而不破坏其封装性
• 可为外部类提供必要的内部功能组件

类在内部有一下几种形式，在另一个类的内部（普通成员--成员内部类/静态成员--静态内部类）。
在方法的内部（普通定义--局部内部类，利用接口匿名定义--匿名内部类）

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

1. 成员内部类

public class Outer {
      private int id=10;
      public void out(){
            System.out.println("这是外部类的方法")；
      }
      //内部类可以访问外部类的私有属性/方法
      public class Inner {
            public void in(){     
                  System.out.println("这是内部类的方法" + id);
            }
      }
}

public static void main(String[] args){
      Outer outer = new Outer();
      //通过
      Outer.Inner inner = outer.new Inner();
      inner.In();
}

2. 静态内部类
   就是成员内部类前面加了static修饰符，此时里面只能访问外部类的静态属性或者方法。
   非静态的在内部类加载的时候还没有加载，所以不能访问。举例略

3. 局部内部类
   在方法里定义的类

public class Outer{
      public void method(){
            class Inner{
                  public void in(){
                  }
            }
      }
}

4. 匿名内部类
   匿名对象的使用，必须继承一个父类或实现一个接口
   没有名字初始化类，不用实例保存到对象中

public class Test{
      public static void main (String[] args){
            //没有名字初始化类，new apple没有名字，不用将实例保存到变量中
            new Apple().eat()；
            // UserService(){}就是个实现类，但是它没有名字，初始化了一个对象赋值给了接口
         userService userService = new UserService(){
                  public void hello(){
                        //实现略
                       }
            }；
      }
}
class Apple{
      public void eat(){
            System.out.println("1");
      }
}
interface UserService{
      void hello();
}