Java面向对象程序设计的基本特征

• 封装
• 继承
• 多态

封装

1. 什么是封装？

封装就是将属性私有化，提供公有的方法访问私有属性。如：

					private String name;
  public String getName(){
    retun name;
  }
  public void setName(){
    this.name = name;
  } 
					

继承

1. 生活中，继承的例子随处可见，如：

2. 使用继承的好处？

使用继承提高代码的复用性

继承

3. 如何实现继承

在Java语言中，用extends关键字表示一个类继承另一个类，例如：

                      public class Son extends Father{
    //其余代码省略
  }
                    

在父类中只定义一些通用的属性与方法，例如：

                    public class Animal{
    private String name;
    pulic Animal(String name){
      //初始化属性值
    }
    public void eat(){
      //吃方法的具体实现
    }
  }
                    

子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法，如：

                    public class Lion extends Animal{
    public Lion(String name){
      super(name);
    }
    public void eat(){
      System.out.println(“继承父类eat()”);
      super.eat();
    }
  }
                    

多态

1. 什么是多态？

指父类中定义的属性与方法被子类继承后，可以具有不同的数据类型或行为。

2. 生活中的多态，如：

多态

3. 多态是通过覆盖父类的方法来实现，在运行是根据传递的对象引用，来实现相应的方法，如：

                    public static void main(String[] args){
    A a = new B();
    a.print();
  }
  static class A{
    void print(){
      System.out.println(“This is A.”);
    }
  }
static class B{
    void print(){
      System.out.println(“This is B.”);
    }
  }
                    

接口

1. Java中的多重继承

接口是实现多重继承的途径

多重继承：子类可以实现多个接口;子类只能继承一个父类

                     class A{}
   class B{}
   class C extends A{}
   interface D{}
   interface E{}
   interface F extends D,E{}
   public class Test extends C implements D,E
                  

使用接口的核心原因：

a. 为了能够向上转型为多个基类型（以及由此带来的灵活性）

b. 与使用抽象类相同:防止客户端程序员创建该类的对象，并确保这仅仅是建立一个接口

注：如果知道某事物应该成为一个基类，那么第一选择应该使它成为一个接口

接口

2. 适配接口

接口最吸引人的原因之一，就是允许同一个接口具有多个不同的具体实现；

它的体现形式通常是一个接受接口类型的方法，而该接口的实现和向该方法传递的对象则取决于方法的使用者。

典型运用就是策略模式

                    public Context(IStrategy strategy){
    this.strategy = strategy;
  }
  Scanner类的构造方法：参数也是使用接口
  public Scanner(Readable source){
    this(source,WHITESPACE_PATTERN)
  }
                

接口

3. 接口中的域

接口中的域默认就是static final

jdk1.5以前其可以实现与enum类似的作用

接口可以嵌套在类或其他接口中

例如java.util.Map中就嵌套了Entry

接口

4. 接口与工厂

接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂模式

内部类

1. 内部类的定义

可以将一个类的定义放在另一个类的定义内部，这就是内部类

2. 当我们建立一个inner class时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的this reference形式的，使得内部类对象可以随意的访问外部类中所有的成员。

                        public class Outer{
         private int index = 100;
         private void print(){
                Inner i = new Inner();
                i.print();
         }
         class Inner{
               private void print(){
                  System.out.println(index);
               }
         }
         public static void main(String[] args){
                Outer o = new Outer();
                o.print();
         }        
}
                      

内部类

3. 使用.this与.new

a. 在内部类中生成对外部类对象的引用.this

                        public class DotThis {
     void f() {
       System.out.println(“DotThis.f()”);
     }
     public class Inner{
        public DotThis outer(){
        //在内部类方法中生成对外部类的引用
           return DotThis.this;
        }
     }
  }
                     

b. 在其他类中创建内部类对象.new要通过外部类的一个引用来创建

                       public class DotNew{
    public class Inner {}
    public static void main(String[] args){
      //其它类要访问内部类时
      //要使用外部类的引用来创建内部类的引用
      DotNew dn = new DotNew();
      DotNew.Inner dni = dn.new Inner();
    }
}
                     

内部类

4. 在方法与作用域内的内部类

可以在一个方法里面或者在任意的作用域内定义内部类，理由如下：

a. 实现了某类型的接口，于是可以创建并返回对其的引用。

b. 解决复杂问题，需要创建一个类来辅助解决，但是又不希望这个类是公共可用的。

内部类

5. 匿名内部类

匿名内部类更像是一个表达式，大概如new XXX(){},它可以理解为两个过程：

a. 继承或实现(new XXX() XXX可以表示类也可以是接口)

b. 实例化

内部类

6. 内部类标识符

外部类$内部类

如果是匿名内部类，则会产生一个数字来表示

泛型

1. 泛型概述

泛型是在JDK1.4之后引入的，实现了参数化类型的概念，使代码可以应用于多种类型。理解了边界(能做什么，不能做什么)所在，你才能成为程序高手。因为只有知道了某个技术不能做到什么，你才能更好的做到所能做的，及弥补它的不足。

泛型

2. 泛型及元组

仅一次方法调用就能返回多个对象

                        class Holder2 <A,B>{
    private A first;
    private B second;
    public Holder2(A a,B b) { first = a; second = b;}
    public String toStrinig() {
         return "(" + first + "," + second +")";
    }
  } 
                      

泛型

3. 泛型接口

                      interface Generator <T> { 
    T next(); 
  } 
  public class Ted implements Generator <String>{
    public String next(){ 
      return ""; 
    }
  }
                      

泛型

4. 泛型方法

必须将泛型参数列表置于返回值之前

                      public class GenericMethods { 
    //将泛型参数列表置于返回值之前
    public <T> void f(T... args){ 
      return ; 
    } 
  }
                   

泛型

5. 擦除

List<String>.class与List<Integer>.class是相同类型的，运行时对应的类型都是list。

擦除丢失了在泛型代码中执行某些操作的能力。任何运行时需要知道确切类型信息的操作都将无法工作。

                      List<String> a = new ArrayList<String>(); 
  List<Integer> b = new ArrayList<Integer>(); 
  System.out.println(a.getClass() == b.getClass()); 
  打印结果: true
                      

泛型

6. 总结

a. 使用泛型的目的在于可表达性,而不仅仅是为了创建类型安全的容器在泛型出现之前,向容器中放的是object,取出来后要下转型

b. 它是一种方法,通过它可以编写出更泛化的代码,这些代码对于它们能够作用的类型具有更少的限制,因此单个的代码段可以应用到更多的类型上

字符串

1. String对象是不可变的

String类中每一个看起来会修改String值的方法,实际上都是创建了一个全新的String对象,以包含修改后的字符串内容. 而最初的String对象丝毫未动。

2. 重载+、+=和StringBuilder

+与+=是java中仅有的两个重载过的操作符， +后面如果是非String类,会调用toString方法，Object的toString方法打印出来的是内存地址。StringBuilder非线程安全，StringBuffer线程安全。

字符串

3. 正则表达式

                      public static void main(String[] args) { 
  //将给定的正则表达式编译到模式中
  Pattern p = Pattern.compile("a*b"); 
  //创建匹配器
  Matcher m = p.matcher("aaaaab"); 
  //与模式进行匹配
  boolean b = m.matches();  
  System.out.println(b);  
  //合一写法(但这样写模式不能重用,适合一次匹配)
  b = Pattern.matches("a*b", "aaaaab"); 
  System.out.println(b); 
  //String中的matches
  String str = "1111"; 
  b= str.matches("\\d*"); 
  System.out.println(b);  
}