java se day12 火推

面向对象已讲解知识点大纲:

-   类
    对象
    引用


-   方法

-   堆栈方法区(内存)

-   构造方法

-   方法的重载

-   私有

-   this

-   静态

-   单例设计模式

-   继承

-   权限修饰符

-   多态

-   抽象类

-   接口

-   内部类

Object 类

p1 == p2

p1.xx(p2);

equals 重点

equals 方法在非空对象引用上实现相等关系： 

自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。 
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。 
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。 
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。 
对于任何非空引用值 x，x.equals(null) 都应返回 false。 



package cn.xdl.demo1;

public class Person {

    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public boolean equals(Object obj) {
        if(obj==null) {
            return false;
        }
        if(this==obj) {
            //先判断地址是否相等, 地址相等表示是同一个对象, 返回为true
            return true;
        }
        //内存地址不同 , 判断obj的类型, 是否与当前类型相同
        if(obj instanceof Person) {
            //类型相同时, 我们比较属性的值是否相同
            Person p = (Person) obj;
            if(p.age != this.age) {
                //年龄不相同
                return false;
            }
            //地址不同, 类型相同, 年龄相同 ,接下来判断姓名
            if(!p.name.equals(this.name)) {
                //姓名不同
                return false;
            }
            //地址不同, 类型相同, 年龄相同 ,姓名相同
            return true;

        }else {
            //类型不同, 无法比较 , 返回false 
            return false;
        }
    }

}

HashCode()方法

这个方法来自Object类, 返回一个int值, 这个方法是为了提高哈希表的性能 !


    一般与Equals方法一起使用 !


规范要求: 

    1.  一致性 , 同一个对象, 属性不改变的情况下,  返回的hashCode值应该固定 !

    2.  相同的两个对象, hashCode值应该一致 !

    3.  hashCode值, 不是用来判断对象是否相同的根据, hashCode值相同, 对象不一定相等!  不过在设计代码时, 我们建议, hashCode值与equals判断的结果保持一致 !

toString方法

用于返回对象的字符串表示形式 !  一般用于对象数据的查看与打印 !

System.out.println方法传入对象时, 其实自动调用的是 对象的toString方法

clone 克隆 (了解)

用于对象的克隆操作

这个方法 由Object实现 !  

我们需要添加克隆标记(实现Cloneable接口)



这个方法的使用 , 存在一些限制,  
默认情况下, 一个对象是无法进行克隆的 ,需要给这个对象的类型, 添加一个可被克隆的标记 !


案例: 

    Person p3 = (Person) p1.clone();
    System.out.println(p3);
    System.out.println(p1);
    System.out.println(p3==p1);
    System.out.println(p3.equals(p1));

基本数据类型与包装类

java.lang.Integer   int

java.lang.Long      long

java.lang.Double    double

java.lang.Character char

java.lang.Boolean   boolean

java.lang.Byte      byte

java.lang.Float     float

java.lang.Short     short

基本数据类型与 包装类如何转换(了解)

什么是装箱? 
    是将一个基本数据类型转换为包装类对象的过程!

什么是拆箱?
    是将一个包装类的对象转换为基本数据类型的过程!

jdk1.5之前:

需要手动拆箱, 和 手动装箱

int a = 10;
//装箱操作
    Integer b = Integer.valueOf(a);
    Integer b2 = new Integer(a);

//拆箱操作
    int c = b.intValue();


例如:  两个Integer 在早期进行加法运算时: 

    Integer a =  new Integer(10);

    Integer b =  new Integer(20);

    int sum = a.intValue()+b.intValue();

    Integer sumI = new Integer(sum);

jdk1.5之后:

编译器, 帮我们 完成了 自动拆箱 和 自动装箱


    Integer a = 10;
    Integer b = 20;
    Integer sum = a+b;

常用方法与属性: 重点

MAX_VALUE : 全局常量, 表示当前包装类型的最大值

字符串转换数据类型


-   通过parseXXX

    int parseInt(String text): 

    这个方法,  用来将一个字符串的数字, 转换为Integer类型

    有时我们经常从网络, 用户 ,数据库等, 读取一些字符串格式的数据, 有可能这些数据是整型的 , 可以通过parseXXX将其转换为对应的类型

-   构造方法

    new Integer(String text);

转换格式 会出现错误:  
    NumberFormatException  数字格式化异常 

String

特性

-   常量池中重复利用

    因为字符串经常在程序中出现 , 当编写了一个字符串后 , 这个字符串会被还存在常量池中, 如果重复出现相同字符串, 则使用同一块内存中的对象 !

    如果重复出现的字符串 是 通过new开辟的空间, 则表示显式指定新空间进行字符串的存储, 就不会拿来重复利用 !

-   String的值无法改变

    String类型的值, 在内存空间中一经确定, 字符序列是无法改变的! 进行拼接字符串, 需要舍弃原有字符串 , 开辟新的空间进行存储 !

    所以不建议, 进行过多的拼接字符串操作 !

    String a = "";
    for(int i=1;i<=100;i++){
        a = a+i;
    }

转义字符 \

将原本在Java中具备特殊含义的字符, 转换为布局含义的普通字符
String text =  "他就是"董飞"";
上述的代码出现了问题, 引号再Java中具备特殊的含义: 

添加转义字符后: 

    String text =  "他就是\"董飞\"";
    输出的结果为: 他就是"董飞"

又来了一个问题,  

String text = "他还是\董飞"

我们可以通过转义字符, 将另一个转义字符转换为普通字符 !

通过转义字符, 可以转化的文本以及含义:

\u+4个数字 : unicode编码 !

\\          : 将转义字符转换为普通字符
\"          : 将双引号转换为普通字符
\r          : 回车
\n          : 换行
\t          : 制表符 , 横向进入下一个单元格

\b          :  退格(了解)
\f          : 走纸换页(了解)

换行符再不同的操作系统下 有不用的写法: 

再Mac os 里换行使用 \n

在Unix 里使用 \r

再windows使用 \r\n 

String常用方法

-   equals :  (重点(*****))

    比较的规则:  

        获取到两个字符串中的字符数组 ,  对两个字符数组中的每一个元素进行比较, 如果都相同, 则返回true; 


源码如下: 

 public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

    6个基本方法: 


    //一个字符串
    String text = "  abcd1ABCD  ";
    //1.    将字符串中的所有字符转换为小写并返回(重点(*))
    System.out.println(text.toLowerCase());
    //2.    将字符串中的所有字符转换为大写并返回(重点(*))
    System.out.println(text.toUpperCase());
    //3.    去除字符串中的前后空白
    System.out.println(text.trim());(重点(*))
    //4.    判断字符串是否以某字符串开头
    System.out.println(text.startsWith(" "));(重点(*))
    //5.    判断字符串是否以某字符串结尾
    System.out.println(text.endsWith("D"));(重点(***))
    //6.    获取字符串的长度(字符序列的长度, 也就是字符串中字符数组的长度)(重点(*****))
    System.out.println(text.length());

(重点(***))
indexOf : 用来查找一个字符 或 字符串 在 当前字符串中的位置 !

四个方法的重载: 

    -   
        参数1: char类型的参数  : 要查找的字符
        从左至右查找一个字符在字符串中的位置
    -   
        参数1.    char类型的参数,  
        参数2.    int类型的 , 表示开始索引 

        从参数2的位置向右查找一个字符的位置

    - 
        参数1.    String类型的参数: 要查找的字符串
        从左至右查找一个字符串在字符串中的位置

    -   
        参数1.    String类型的参数: 要查找的字符串
        参数2.   int类型的 , 表示开始的索引
        从指定的开始位置(参数2) , 向右查找一个字符串的位置 !
查找的结果:  

    1. 从左至右 查找到的第一个匹配的字符或字符串的下标!

    2.  如果查询不到 , 返回-1;

(熟悉))
lastIndexOf : 用来查找一个字符 或 字符串 在 当前字符串中的位置 !(反向查找)

四个方法的重载: 

    -   
        参数1: char类型的参数  : 要查找的字符
        从右至左查找一个字符在字符串中的位置
    -   
        参数1.    char类型的参数,  
        参数2.    int类型的 , 表示开始索引 

        从参数2的位置向左查找一个字符的位置

    - 
        参数1.    String类型的参数: 要查找的字符串
        从右至左查找一个字符串在字符串中的位置

    -   
        参数1.    String类型的参数: 要查找的字符串
        参数2.   int类型的 , 表示开始的索引
        从指定的开始位置(参数2) , 向左查找一个字符串的位置 !
查找的结果:  

    1.  从右至左 查找到的第一个匹配的字符或字符串的下标!

    2.  如果查询不到 , 返回-1;

(重点(**))
char charAt(int index)

参数1. 要获取字符的索引

从一个字符串中 取出指定索引下的字符, 并返回

(重点(***))
String substring : 从一个字符串中截取其中一部分 并返回

方法存在两个重载方法: 


    - 
        参数1.  截取的开始位置(包含)

    表示从指定的开始位置截取到字符串的结尾 

    -   
        参数1. 截取的开始位置(包含)
        参数2. 截取的结束位置(不包含)

    表示从指定的开始位置 截取到 指定的结束位置!



案例: 

    String text = "床前明月光,玻璃好上霜,要不及时擦,整不好得脏";
    String newText = text.substring(5);
    System.out.println(newText);
    String newText2 = text.substring(5,text.length());
    System.out.println(newText2);

(重点(*))
byte[] getBytes()

    存在两个方法的重载:

    -   
        没有参数列表 
        按照当前系统的默认编码表 将当前的字符串打碎(还原)为字节数组,并返回

    -   
        参数1. 指定的编码表的名称()
            可以填入:  
                <1> : iso-8859-1 : 纯英文编码
                <2> : gbk        : 简体中文编码
                <3> : gb2312     : 简体中文编码
                <4> : utf-8      : unicode编码
        按照指定的编码表 将当前的字符串打碎(还原)为字节数组,并返回