java笔记--面向对象编程

2.1 构造器：

1. 可以在构造器中调用另一个构造器，但是只能作为构造器方法体的第一条语句，并且不能使用构造函数的名字，只能使用关键字 this

   值得说明的是，这里的 this 并不是正在被构造的对象的引用，相反，它是一种特殊的语法，只用在同类的另一个构造器中

2.2 包

1. 导入包中，通配符只能导入类，不能导入包。你不能使用 import java.* 以导入所有以java开始的包。

2. 当导入了多个包仍然有名称冲突时，可以导入自己想要的那一个类
   import java.sql.;
   import java.util.;
   import java.util.Date;
   // 这样以下的 Date 类就代表 java.util.Date 了

3. 静态导入：java 允许静态导入一个类中的静态方法和静态变量（import 导入最细到方法）
   package xinho.unit1;
   import static java.lang.Math.; // 静态导入，所以无需类名作为前缀的使用Math类的静态方法和静态变量
   import static java.lang.Math.pow; // 也可以只导入某一个静态方法或者变量
   public class demo02 {
   public static void main(String[] args) {
   Double pi = PI; // 因为使用了 import static java.lang.Math.;
   }
   }
   2.3 静态嵌套类

4. 静态嵌套类无法访问外部类的变量，因为它并不依附于任何一个外部类。但是外部类可以访问静态嵌套类的任何访问权限的变量（要先构造对象）

5. 静态类可以在任何地方被任何人通过全限定名构造，和使用一般的类没有任何区别。使用静态嵌套类只是把从属关系显示的更清楚了一点而已。
   package xinho.unit1;
   public class demo03 {
   public String publicName;
   protected String protectedName;
   private String privateName;
   String defaultName;
   private static class myclass {
   public String spublicName;
   protected String sprotectedName;
   private String sprivateName;
   String sdefaultName;
   }
   public myclass getSon() {
   return new myclass();
   }
   public static void visitStatic(){
   myclass class01 = new myclass();
   String s = class01.sprivateName;
   }
   public static void main(String[] args) {
   demo03 demo = new demo03();
   demo03.myclass class01 = new demo03.myclass();
   }
   }
   2.4 内部类

6. 一个外部类可以对应多个内部类。但一个内部类必须对应一个外部类，否则无法构造（所以任何static的方法中不能调用内部类的构造器l）

7. 内部类和外部类之间互访，哪怕是private。（需要说明的是，由于一个内部类必须依赖一个外部类，所以内部类可以直接通过外部类的变量名访问，但由于一个外部类可以对应多个内部类，所以外部内必须先构造一个内部类才能使用它的变量）
   package xinho.unit1;
   public class demo02 {
   public String publicName;
   protected String protectedName;
   private String privateName;
   String defaultName;
   private class myclass{
   public String publicName;
   protected String protectedName;
   private String privateName;
   String defaultName;
   private String hhha;
   int age;
   public myclass(){}
   public myclass(String name, int age){
   this.publicName = name;
   this.age = age;
   hhha = “hhha”;
   }
   public void visitFather(){
   publicName = “公共的名字”;
   privateName = “私有的名字”;
   protectedName = “受保护的名字”;
   defaultName = “默认的名字”;
   System.out.println(“publicName:”+publicName);
   System.out.println(“privateName:”+privateName);
   System.out.println(“protectedName:”+protectedName);
   System.out.println(“defaultName:”+defaultName);
   }
   }
   public void visitSon(){
   myclass class01 = new myclass(“张三”,19);
   myclass class02 = new myclass(“张四”,19);
   System.out.println(class01.publicName + " " + class01.age + " " + class01.hhha);
   System.out.println(class02.publicName + " " + class02.age);
   }
   public myclass getSon(){
   return new myclass();
   }
   public static void main(String[] args) {
   demo02 demo = new demo02();
   demo.visitSon();
   // 通过外部类获取一个内部类，这个内部类
   myclass class01 = demo.getSon();
   class01.visitFather();
   // myclass class02 = new myclass();// 内部类不能在static方法中构造
   }
   }

8. 在任何其他类中，无法引用内部类（抛出无法在静态的上下文中引用的异常）
   2.5