黑马程序员————内部类、包、Object、scanner以及String

------- android培训、java培训、期待与您交流！ ----------

1:内部类
 (1)把类定义在一个类的内部。
 (2)特点：
  A:内部类可以直接使用外部类的成员，包括私有。
  B:外部类要使用内部类成员，必须创建对象使用。
 (3)内部类的分类：
  局部内部类：定义在方法中的内部类
  成员内部类：定义在类中方法外的内部类
 (4)成员内部类
  class Outer {
   class Inner {
   
   }
  }

  普通的修饰的时候：
   外部类名.内部类名 变量 = 外部类对象.内部类对象;
   Outer.Inner oi = new Outer().new Inner();

   class Outer {
   static class Inner {
        static void method(){}
   }
  }
  用静态修饰内部类时：
   外部类名.内部类名 变量 = 外部类名.内部类对象
   Outer.Inner oi = new Outer.Inner();

  用静态修饰内部类和方法时：
   Outer.Inner.method()
  成员内部类：
   private：为了数据的安全。
   static：为了方便调用。
 (5)局部内部类
  A:带名字的局部内部类
   class Outer {
    public void method() {
     final int a = 10;
     class Inner {
      public void show() {
       System.out.println("show");
       System.out.println(a);
      }

      Inner i = new Inner();
      i.show();
     }
    }
   }
  B:匿名内部类
   a:没有名字的内部类。其本质是一个对象。是通过多态来实现的。
   b:前提：存在一个抽象类或者接口。
   c:格式：
    new 抽象类或者接口() {
     重写父类方法;
    };

    本质：是一个继承了类或者实现了接口的子类匿名对象。
 
2:包
 (1)包就是永远区分相同类在不同文件夹下。其本质就是一个文件夹。
 (2)包的作用：让相同类名的类可以存在。为了组织代码。cn.itcast.action   cn.itcast.service  cn.itcast.db
 (3)定义包：
  package 包名.包名...;
 (4)带包的编译和运行
  A:方式一
   手动式
   a:javac编译代码
   b:手动建立包，把class扔进去
   c:java执行，带全路径
  B:方式二
   自动式
   a:通过javac编译自动生成包
    javac -d . 文件名
   b:通过java运行class文件
    java 包名.包名.class文件名不带扩展名
 (5)不同包下的类之间的访问。
  权限够大才行。

  以后，我们所有定义的类都用public修饰。
 (6)面试题：
  在同一个java文件中，可不可以有多个类?可以。
  而我们知道类是可以用public修饰的,那么，可不可以多个类都用public修饰?不可以。
  并且，一般的时候，如果有main方法也存在的时候，都是public修饰带main那个类。
  文件名必须和该public修饰的类名一致。

3:导包(掌握)
 (1)如果多次使用一个多级包的类，每次带全路径太麻烦，我们就考虑使用导包。
 (2)导包的格式：
  import 包名.包名...;

  注意：
   在同一个包下如果有多个类被使用，可以使用通配符*来导入，但是不建议。
   推荐：使用谁导入谁。
 (3)面试题：
  package，import，class出现的位置?
   package > import > class

4:权限修饰符
 (1)用于保证在不同的情况下可以使用
 (2)使用如下
    本类 同一个包下 不同包下的子类 不同包下的无关类
  private  Y
  默认  Y Y
  protected Y Y  Y
  public  Y Y  Y  Y

常见的组合规则：
 权限修饰符+abstract/final/static+...

我们到底怎么用(开发的时候一般都这么做)：
 类：
  public class Demo {
  
  }

 成员变量：
  变量：private String name;  加上相应的getter和setter
  常量：public static final int X = 10;

 构造方法：
  不让外界创建：private Demo(){}
  大部分：public Demo(){}

 成员方法：
  不让外界用：private void show(){}
  大部分：public void method(){}
  抽象方法：public abstract void function();

2:Object类
 (1)是定义在java.lang包下的，是所有类的超类。所有类都直接或者间接的继承自Object类。
  父类：超类，根类，基类。
  子类：派生类。
 (2)要掌握的方法：
  public String toString():返回对象的字符串表示形式。
   默认情况下的组合：类的全路径名称+@+对象的哈希值的十六进制表示。
   这种做法对我们来说，一般没有意义，所以，建议重写。
   重写做法：一般是把所有的成员变量组合成一个字符串返回。
   实在不愿意自己写，自动生成。
  public boolean equals(Object obj):比较对象的地址值是否相同。
   默认情况下，比较的是对象的地址值是否相同。
   如果有自己的特殊需求，请重写Object类的该方法。
   怎么重写呢?
/*
    public boolean equals(Object obj) {
     if(this == obj) {
      return true;
     }

     if(!(obj instraceof Student)) {
      return false;
     }

     Student s = (Student) obj;
     return this.name.equals(s.name) && this.age == s.age;
    }

*/
    如果有多个成员变量，把多个比较用&&连接即可。
     引用类型用equals()方法。
     基本类型用==号即可。
   实在不愿意自己写，自动生成。
 (3)面试题：
  ==和equals()的区别?
  ==:
   可以比较基本类型，也可以比较引用类型。
   比较基本类型，比较的是值是否相同。
   比较引用类型，比较的是地址值是否相同。
  equals:
   只能比较引用类型。
   默认情况下，比较的是地址值是否相同。
   如果想比较内容，请自己重写Object类的equals()方法。
1:Scanner的概述
 (1)Scanner是JDK5以后出现的方便我们从键盘接受数据的类。
 (2)Scanner的构造格式：
  Scanner sc = new Scanner(System.in);

  System.in 是System类下面有一个静态的成员变量in。它的类型是InputStream。 
     代表的是标准键盘输入流。也就是键盘录入数据。
  Scanner是对其进行了封装，提供了各种转换功能。方便我们获取到想要的数据类型的数据。
 (3)要掌握的两个功能：
  A:返回int类型
   public int nextInt()
  B:返回String类型
   public String nextLine()
   public String next()
  
  注意事项：
   先int,在String会有问题。
   解决方案：
    重新建立Scanner对象。//一般不会这样做。因为消耗资源
    把所有的数据都看成是String类型，将来转换为int类型。
    通常使用next()方法而不用nextLine()方法

2:String类的概述和使用(掌握)
 (1)由多个字符组成的一串数据。
 (2)构造方法：
  A:String s = new String();
  B:String s = new String(byte[] bys);
  C:String s = new String(byte[] bys,int startIndex,int count);
  D:String s = new String(char[] chs);
  E:String s = new String(char[] chs,int startIndex,int count);
  F:String s = new String(String s2);
  G:String s = "hello";

  长使用：
   BCDEG
 (3)面试题：
  A:字符串一旦被赋值就不能被改动。
   注意：这里的改动指的是字符串的内容，而不是字符串对象的引用。
  B:String s = new String("hello");和String s = "hello";有区别吗?是什么呢?
   有。
   前者创建了两个对象。
   后者创建了一个对象。
  C:看程序，写结果
   String s1 = new String("hello");
   String s2 = new String("hello");
   System.out.println(s1==s2);F
   System.out.println(s1.equals(s2));T

   String s3 = new String("hello");
   String s4 = "hello";
   System.out.println(s3==s4);F
   System.out.println(s3.equals(s4));T

   String s5 = "hello";
   String s6 = "hello";
   System.out.println(s5==s6);T
   System.out.println(s5.equals(s6));T
  D:看程序，写结果
   String s7 = "hello";
   String s8 = "world";
   String s9 = "helloworld";
   System.out.println(s9==s7+s8);F
   System.out.println(s9=="hello"+"world");F

   变量就直接造，常量先找，如果有就使用，否则就造。
 (4)字符串的常见功能：
  A:判断功能
   boolean equals(Object obj)与一个制定字符串比较
   boolean equalsIgnoreCase(String str)将此 String 与另一个 String 比较，不考虑大小写
   boolean contains(String str)
   boolean startsWith(String str)测试此字符串是否以指定的前缀开始
   boolean endsWith(String str)测试此字符串是否以指定的后缀结束。
   boolean isEmpty()是否为空  当且仅当 length() 为 0 时返回 true

  B:获取功能
   int length()
   char charAt(int index)     返回指定索引处的 char 值。
   int indexOf(int ch)  返回指定字符在此字符串中第一次出现处的索引。
   int indexOf(String str);返回指定子字符串在此字符串中第一次出现处的索引。
   int indexOf(int ch,int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
   int indexOf(String str,int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
   String substring(int start) 返回一个新的字符串，它是此字符串的一个子字符串。
   String substring(int start,int end) 返回一个新字符串，它是此字符串的一个子字符串

  C:转换功能
   byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
   char[] toCharArray() 将此字符串转换为一个新的字符数组。
   static String copyValueOf(char[] chs) 返回指定数组中表示该字符序列的 String。
   static String valueOf(char[] chs)返回 char 数组参数的字符串表示形式。
   static String valueOf(int i)返回 int 参数的字符串表示形式。
   String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写
   String toUpperCase()使用默认语言环境的规则将此 String 中的所有字符都转换为大写
   String concat(String str) 将指定字符串连接到此字符串的结尾。

  D:其他功能
   String replace(char old,char new)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
   String replace(String old,String new)

   String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。

   String trim() 返回字符串的副本，忽略前导空白和尾部空白。
   
   int compareTo(String str)按字典顺序比较两个字符串。
   int compareToIgnoreCase(String str)  按字典顺序比较两个字符串，不考虑大小写。
 (5)案例：
  A:遍历字符串
   String s = "hello";
   
   for(int x=0; x<s.length(); x++) {
    System.out.println(s.charAt(x));
   }
  B:统计字符串中大写字母，小写字母以及数字字符出现的次数
  C:把一个字符串的首字母变成大写，其他的全部小写
  D:统计大串中小串出现的次数