类的抽象是指将类的实现和类的使用分离开。
实现的细节被封装并且对用户隐藏 ， 这被称为类的封装 。
面向过程的范式重点在于设计方法 。 面向对象的范式将数据和方法耦合在一起构成对象 。

• 类的关系：关联 、 聚合 、 组合以及继承 。
  • 关联

• 聚集和组合

示例学习：设计栈
用数组实现：

/**
 * 用数组实现一个栈
 */
public class StackOfIntegers {
    //定义了栈的数组
    private int[] elements;
    //size表示栈内元素大小，size-1就是目前的栈顶元素
    private int size;
    //设置默认的数组大小
    private static final int DEFAULT_CAPACITY=16;

    public StackOfIntegers(){
        elements=new int[DEFAULT_CAPACITY];
    }
    //入栈
    public void push(int value){
        if(size>=elements.length) {
            //如果size>=数组的大小，就将数组的大小扩容
            int[] temp = new int[elements.length * 2];
            System.arraycopy(elements,0,temp,0,elements.length);
            elements=temp;
        }
        elements[size]=value;
        size++;
    }

    //出栈
    public int pop(){
        //要弹出的元素目前在栈顶，size是共有的元素长度，下标是size-1
        int number= elements[size-1];
        //弹出后，size长度减少一个
        size--;
        return number;

    }

    //判栈空
    public boolean empty(){
        return size==0;
    }

    public static void main(String[] args){
        StackOfIntegers stackOfIntegers=new StackOfIntegers();
        for(int i=0;i<10;i++)
            stackOfIntegers.push(i);
        while (!stackOfIntegers.empty())
            System.out.print(stackOfIntegers.pop()+" ");
    }

}

2.数值包装类

出于对性能的考虑 ， 在 Java 中基本数据类型不作为对象使用 。 因为处理对象需要额外的系统开销 ， 所以 ， 如果将基本数据类型当作对象 ， 就会给语言性能带来负面影响 。 然而 ，Java 中的许多方法需要将对象作为参数 。 Java 提供了一个方便的办法 ， 即将基本数据类型并入对象或包装成对象 （ 例如 ， 将 int 包装成 Integer 类 ， 将 double 包装成 Double 类 ， 将char 包装成 Character 类 ） 。 通过使用包装类 ， 可以将基本数据类型值作为对象处理 。 Java为基本数据类型提供了 Boolean 、 Character 、 Double 、 Float 、 Byte 、 Short 、 Integer • 和Long 等包装类 。 这些包装类都打包在 java . lang 包里 。

• 数值包装类有一个有用的静态方法 valueOf（String s ) 。 该方法创建一个新对象 ， 并将它初始化为指定字符串表示的值 。 例如 ，

  
  
• Integer 类中的 parselnt 方法将一个数值字符串转换为一个 int 值 ，而且使用过 Double 类中的 parseDouble 方法将一个数值字符串转变为一个 double 值 。 每个数值包装类都有两个重载的方法 ， 将数值字符串转换为正确的以 10 ( 十进制 ） 或指定值为基数 （ 例如 ， 2 为二进制 ， 8 为八进制 ， 16 为十六进制 ） 的数值 。

3.基本类型和包装类类型之间的自动转换

将基本类型值转换为包装类对象的过程称为装箱 （ boxing ) , 相反的转换过程称为开箱 Java 允许基本类型和包装类类型之间进行自动转换 。 如果一个基本类型值出现在需要对象的环境中 ， 编译器会将基本类型值进行自动装箱 ； 如果一个对象出现在需要基本类型值的环境中 ， 编译器会将对象进行自动开箱 。

4.String类

1)不可变字符串

String 对象是不可变的 ， 它的内容是不能改变的。
String s=“Java”；
s=“HTML”；

第一条语句创建了一个内容为 java的 String 对象 ， 并将其引用賦值给S，第二条语句创建了一个内容为 " HTML " 的新 String 对象 ， 并将其引用賦值给 s 。 陚值后第一个 String 对象仍然存在 ， 但是不能再访问它 ， 因为变量 s 现在指向了新的对象 。

2)限定字符串

因为字符串在程序设计中是不可变的 ， 但同时又会频繁地使用 ， 所以 Java 虚拟机为了提高效率并节约内存 ， 对具有相同字符序列的字符串直接量使用同一个实例 。 这样的实例称为限定的 （ interned ) 字符串 。

3)字符串的替换和分离

4)正则表达式

• 匹配字符串使用String类中的maches方法
  " Java is fun " . matches ( " Java . * " )
• 正则表达式的语法

• 例1：社会安全号的模式是 XXX - XX - XXX , 其中 X 是一位数字。
  [\d]{3}-[\d]{2}-[\d]{3}
  解析:[\d]表示数字，{3}表示前面的模式出现次数，在这里就是3个数字。

• 例2:偶数以数字 0 、 2 、 4 、 6 或者 8 结尾
  [\d][02468]
  解析：[\d]表示可以有0到多个数字，[02468]表示0或2或4或6或8

• 例3:电话号码的模式是 （ XXX ) XXX - XXXX ， 这里 X 是一位数字 ， 并且第一位数字不能为 0
  \([1-9][//d]{2}\)[\d]{3}-[\d]{4}

• 例4：假定姓由最多 25 个字母组成 ， 并且第一个字母为大写形式
  [A-Z][//d]{1,24}

• 例5：Java 标识符必须以字母 、 下划线 （ - ) , 或者美元符号 （ $ ) 开始,不能以数字开头 。
  标识符是一个由字母 、 数字 、 下划线 （ - ) 和美元符号组成的字符序列 。
  [a-zA-Z_$][\w]*

• 替换和分割字符串

System . out . println ( " Java Java Java " .replaceAll(" v \\ w " , " wi " ) );
Jawi Jawi Jawi
System . out . println ( " Java Java Java " . replaceFirst( '' v\\w " , " wi " ) ) ;
Jawi Java Java 

5)字符串与数组之间的转换

• 为了将字符串转换成一个字符数组 ， 可以使用 toCharArray() 方法
  char [ ] chars = " Java " . toCharArray ();

• 使用方法 getChars ( int srcBegin . int srcEnd , char [ ] dst , int dstBegin ) 将下标从 srcBegin 到 srcEnd - 1 的子串复制到字符数组 dst 中下标从 dstBegin 开始的位置。

  
  
• 为了将一个字符数组转换成一个字符串 ， 应该使用构造方法 String ( Char [] ) 或者方法valueof ( char [ ] )

String str=new String(new char[]{'J','a','v','a'});
String str=String.valueOf(new char[]{'J','a','v','a'});

6）将字符和数值转换成字符串

• 可以使用 Double . parseDouble ( str ) 或者 Integer.parselnt ( str ) 将一个字符串转换为一个 double 值或者一个 int 值。
• 为了将 double 值 5 . 44 转换成字符串 ， 可以使用 String . valueof ( 5 . 44 ) 。

5.StringBuilder 和 StringBuffer 类

— 般来说 ， 只要使用字符串的地方 ， 都可以使用 StringBuilder / StringBuffer类 。StringBuilder/StringBuffer类比 String 类更灵活 。 可以给一个 StringBuilder或 StringBuffer 中添加 、 插入或追加新的内容 ， 但是 String 对象一旦创建 ， 它的值就确定了 。
StringBuilder：线程非安全的
StringBuffer：线程安全的。
如果是多任务并发访问 ，就使用 StringBuffer。

• 示例学习
  判断回文串时忽略既非字母又非数字的字符。

package java_04_基础习题练习.第十章_面向对象的思考;

import java.util.Scanner;



/**
 * 判断回文串时忽略既非字母又非数字的字符
 */
public class HuiwenIgnoreNonwd {
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        String s=input.nextLine();
        System.out.print("忽略非字母又非数字的字符后"+s+"是回文串吗？"+isHuiWen(s));
    }

    private static boolean isHuiWen(String s) {
        //调用过滤方法返回新串
        String filters=filter(s);
        return filters.equals(reverse(filters));
    }

    private static String filter(String s) {
        StringBuilder stringBuilder=new StringBuilder();
        for(int i=0;i<s.length();i++){
            //如果字母是数字或字符
            char c=s.charAt(i);
            if(Character.isLetterOrDigit(c))
                stringBuilder.append(c);
        }
        return stringBuilder.toString();
    }

    private static String reverse(String s){
        StringBuilder stringBuilder=new StringBuilder(s);
        return stringBuilder.reverse().toString();
    }

}