java从入门到放弃（5）

　　static/**  * static：静态的  * static可以用来修饰属性、方法、代码块、内部类  *  * static修饰属性:静态变量（或类变量）  * 属性按是否使用static修饰，又分为静态属性 vs 非静态属性  * 静态变量：我们创建类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时  *            其他对象调用此静态变量时，是修改过了的。  * static修饰属性的其他说明：  * 1.静态变量随着类的加载而加载，可以通过类.静态变量的方式进行调用  * 2.静态变量的加载要早于对象的创建  * 3.由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法去的静态域中  *  * 静态属性举例:system.out;Math.Pi  *  * 使用static修饰方法，静态方法  * 随着类的加载而加载，可以通过＂类.静态方法＂的方式进行调用  * 静态方法中，只能调用静态的方法或属性  * 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性  *  * static注意点：  * 在静态的方法内，不能使用this关键字、super关键字  * 关于静态属性和静态方法的使用，要从生命周期的角度理解  *  * 开发中，如何确定一个属性是否要声明为static的?  * 属性是可以被多个对象所共享，不会随着对象的不同而不同的。  * 开发中，如何确定一个方法是否要声明为static的?  * 操作静态属性的方法通常设置为static  * 工具类的方法，习惯上声明为static  */ public class StaticTest {     public static void main(String[] args) {         Chinese.nation = ＂中国＂;         Chinese c1 = new Chinese();         c1.name = ＂张三＂;         c1.age = 20;         c1.nation = ＂CHN＂;          Chinese c2 = new Chinese();         c2.name = ＂李四＂;         c2.age = 10;          System.out.println(c1.nation);          c1.eat();         Chinese.show();     } } //中国人 class Chinese{     String name;     int age;     static String nation;      public void eat(){         System.out.println(＂吃饭＂);     }     public static void show(){         //不能调用非静态的结构         //eat();         System.out.println(＂中国人＂);         //可以调用静态的结构         System.out.println(Chinese.nation);     } } 代码块
　　代码块(或初始化块)的作用：对Java类或对象进行初始化/**  * 类的成员之四：代码块  * 代码块的作用：用来初始化类、对象  * 代码块如果有修饰的话，只能使用static  * 分类：静态代码块 vs 非静态代码块  *  * 静态代码块  *  内部可以有输出语句  *  随着类的加载而执行，只会执行一次  *  作用:初始化类的信息  *  如果一个类中定义多个静态代码块，则按照声明的先后顺序执行  *  静态代码块的执行要优先于非静态代码块的执行  *  静态代码块内只能调用静态的属性和方法，不能调用非静态的结构  *  * 非静态代码块  * 内部可以有输出语句  * 随着对象的创建而执行，每创建一个对象，就执行一次非静态代码块  * 作用：可以在创建对象时，对对象的属性进行初始化。  * 非静态代码块内可以调用静态的属性和方法也能调用非静态的  *  * 对属性可以赋值的位置  * 1.默认初始化  * 2.显示初始化  * 3.构造器中初始化  * 4.有了对象以后可以通过对象.属性，对象.方法赋值  * 5.在代码块中赋值  * 执行顺序 1-2、5-3-4（2和5可以同时执行）  *  */ public class BlockTest {     public static void main(String[] args) {         String desc = Person.desc;         Person p1 = new Person();      } }  class Person{     //属性     String name;     int age;     static String desc = ＂人＂;     //构造器     public Person(){      }     public Person(String name,int age){         this.name = name;         this.age = age;     }     //静态代码块     static{         System.out.println(＂hello static block＂);     }     //非静态代码块     {         System.out.println(＂block＂);     }     //方法     public void eat(){         System.out.println(＂吃饭＂);     }      public static void info(){         System.out.println(＂static info＂);     }  }final
　　在Java中声明类、变量和方法时，可使用关键字final来修饰,表示＂最终的＂/**  * final：最终的  *  * 1.final可以用来修饰的结构:类、方法、变量  * 2.final用来修饰一个类：此类不能被其他类继承  * 比如String类 System类 StringBuffer类  * 3.final用来修饰方法：表明此方法不可以被重写  * 比如getClass();  * 4.final用来修饰变量:此时的变量就称为常量  * final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器初始化  * final修饰局部变量:尤其是使用final修饰形参时，表面此形参是一个常量，当我们调用此方法时一旦赋值，不能修改  * static final用来修饰属性称为全局常量  */ public class FinalTest {     final int WIDTH = 10;     final int LEFT;     final int RIGHT;      {         LEFT = 1;     }     public FinalTest(){         RIGHT = 2;     }     public FinalTest(int n){         RIGHT = n;     }     public void doWidth(){ //        width = 20;     }     public void show(){         final int NUM = 10;     }     public void show(final int num){         System.out.println(num);     }        public static void main(String[] args) {         int num = 10;         num = num + 5;         FinalTest test = new FinalTest();         test.show(10);     } }  final class FinalA{  } 抽象类和抽象方法
　　随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父 类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。import org.omg.CORBA.PERSIST_STORE;  /**  * abstract关键字的使用  * 可以用来修饰的结构:类、方法  *  * abstract修饰类：抽象类  * 此类不能实例化  * 抽象类中一定有构造器，便于子类实例化调用  * 开发中都会提供抽象类的子类，让子类对象实例化，完成相关的操作  *  * abstract修饰方法：抽象方法  * 抽象方法只有方法的声明，没有方法体  * 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法  * 若子类重写了父类中的所有抽象方法后，此类方可实例化  * 若子类没有重写父类中的所有方法，则子类也是一个抽象类  */ public class AbstractTest {     public static void main(String[] args) {         //一旦类抽象了，就不可实例化 //        Person p1 = new Person(); //        p1.eat();     } } abstract class Person{     String name;     int age;      public Person(){      }     public Person(String name,int age){         this.name = name;         this.age = age;     }      public abstract void eat();      public void walk(){         System.out.println(＂人走路＂);     } }  class Student extends Person{     public void eat(){         System.out.println(＂学生吃饭＂);     } }  接口
　　接口(interface)是抽象方法和常量值定义的集合/**  * 接口的使用  * 接口使用interface来定义  * java中，接口和类是并列的两个结构  * 定义接口中的成员：  * 全局常量:public static final的常量，书写时可以省略  * 抽象方法：  * 静态方法  * 默认方法  *  * 接口中不能定义构造器，意味着接口不可以实例化  * 接口通过让类去实现(implements)的方法来使用的  * 如果实现类覆盖了接口中的所有方法，则此实现类可以实例化  * 如果没有覆盖所有抽象方法，那么此类仍然为抽象类  *  * java类可以实现多个接口弥补了java单继承性的局限性  * 格式：class AA extends BB implements 接口  *  * 接口的具体使用，体现多态性  * 接口，实际上可以看作是一种规范  *  */ public class InterfaceTest {     public static void main(String[] args) {         System.out.println(Flyable.MAX_SPEED);          Plane p1 = new Plane();         p1.fly();     } } interface Flyable{     //全局常量     public static final int MAX_SPEED = 7900;     int MIN_SPEED = 1;     //抽象方法     public abstract void fly();     void stop(); } interface Attackable{     void attack(); }  class Plane implements Flyable{      public void fly() {         System.out.println(＂飞机起飞＂);     }      public void stop() {         System.out.println(＂飞机停止＂);     } }  class Bullet extends Object implements Flyable,Attackable{      public void fly() {      }      public void stop() {      }      public void attack() {      } } /**  *  * JDK8，除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法  *  *  */ public interface CompareA {     //静态方法     public static void method1(){         System.out.println(＂CompareA＂);     }     //默认方法     public default void method2(){         System.out.println(＂2＂);     }     default void method3(){         System.out.println(＂3＂);     } } import java10.CompareA;  public class SubClassTest {     public static void main(String[] args) {         SubClass s = new SubClass();          //接口中定义的静态方法，只能通过接口调用         CompareA.method1();         //通过实现类的对象，可以通过调用接口中的默认方法         //如果实现类重写了接口中的默认方法，调用时仍然调用的时重写以后的方法         s.method2();         //如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法         //那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。         //如果实现类实现了多个接口，而这多个接口定义了同名同参的默认方法，         //那么在实现类没有重写此方法的情况下会报错         s.method3();      } } class SubClass implements CompareA{     //重写     public  void method2(){         System.out.println(＂2＂);     } } 内部类
　　当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。import org.omg.CORBA.PERSIST_STORE;  /**  * 类的内部成员之五:内部类  * 1.java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类  *  * 内部类分类：成员内部类，局部内部类  *  * 成员内部类  *  一方面:作为外部类的成员:  *  调用外部类的结构  *  可以被static修饰，可以被四种不同的权限修饰  *  *  另一个方面:作为一个类:  *  类内可以定义属性、方法、构造器。  *  可以被final修饰，可以被abstract修饰  *  */ public class InnerClassTest {     public static void main(String[] args) {         //创建实例（静态的成员内部类）         Person.DD dd = new Person.DD();         dd.show();          //创建实例（非静态的内部成员内部类）         Person p = new Person();         Person.FF f = p.new FF();         f.SS();     } } class Person{     String name;     int age;     public void eat(){         System.out.println(＂ee＂);     }      //成员内部类     static class DD{         String name;         int age;         public void show(){             System.out.println(＂aaa＂);         }     }     class FF{         String name;         public void SS(){          }         public void display(String name){             System.out.println(name);             System.out.println(this.name);             System.out.println(Person.this.name);         }     }     public void method(){         //局部内部类         class AA{          }     }     {   //局部内部类         class BB{          }     }     public Person{         //局部内部类         class CC{          }     }  }