第五章 面向对象（基础篇）

1、对象的创建

　　类名　　对象名称 = null；　　　　//声明对象

　　对象名称 = new 类名();　　　　　 //实例化对象

　　类名 对象名称 = new 类名()　　　 //一步完成

2、匿名对象

　　匿名对象就是没有明确给出名称的对象。一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

　　匿名对象的应用：其在实际开发中基本上都是作为其他类实例化对象的参数传递的。

 3、String

　　1、实例化String对象的两种方法
　　　　直接为String赋值
　　　　String name = "Li";
　　　　直接调用String的构造方法
　　　　String name = new String("Li");
　　2、String内容的比较
　　　　使用 “ == ” 进行比较
　　　　此时进行比较的是String类型引用的地址，并非其堆中的内容
　　　　使用 equals 方法对String内容进行比较
　　　　public boolean equals(String str);
　　　　使用 equals方法的作用是将其内容进行比较
　　3、String两种实例化的区别
　　　　直接为String赋值实际上就是将一个在堆上开辟好的堆内存空间的使用权交给了该对象，这种方法所带来的好处就是，如果一个字符串已将被一个名称引用，以后有相同的字符串声明时，就不会再重新开辟空间，而继续使用已经开辟好的堆内存。
　　　　直接使用String的构造方法，利用new()进行实例化，无论如何都会在开辟一个新的空间。
　　4、字符串中的内容不可变
　　　　一个String对象的内容的改变实际上是通过内存地址的“断开---连接”变化完成的，而本身字符串中的内容并没有任何的变化。
　　5、String类常用的操作方法

序号	方法定义	类型	描述
1	public String(char[] value)	构造	直接将一个字符数组变为一个字符串
2	public String(char[] value, int offset, int count)	构造	将一个指定范围的字符数组变为字符串
3	public String(byte[] bytes)	构造	将一个byte数组全部转变为字符串
4	public String(byte[] bytes, int offset, int length)	构造	将指定范围的byte数组变为字符串
5	public char[] toCharArray()	普通	将一个字符串变为字符数组
6	public char charAt(int index)	普通	将一个字符串中取出指定位置的字符
7	public char getBytes()	普通	将一个字符串变为byte数组
8	public int length()	普通	取得字符串长度
9	public int indexOf(String str)	普通	从头开始查找指定的字符串位置，找不到返回-1
10	public int indexOf(String str, int fromIndex)	普通	从指定位置开始查找指定的字符串位置
11	public String trim()	普通	清除左右两端的空格
12	public String substring(int beginIndex)	普通	从指定位置开始，一直到尾进行字符串的截取
13	public String substring(int begin, int end)	普通	指定截取字符串的开始点和结束点
14	public String[] split(String regex)	普通	按照指定的字符串对字符串进行拆分
15	public String toUpperCase()	普通	将一个字符串全部变为大写字母
16	public String toLowerCase()	普通	将一个字符串全部转变为小写字母
17	public boolean startsWith(String prefix)	普通	判断是否以指定的字符串开头
18	public boolean endsWith(String suffix)	普通	判断是否以指定的字符串结尾
19	public boolean equals(String str)	普通	判断两字符串的内容是否相等
20	public boolean equalsIgnoreCase(String str)	普通	不区分大小写比较两个字符串是否相等
21	public  String replaceAll(String regex, String replacement)	普通	字符串替换

　　6、使用this调用构造方法
　　　　由于构造方法是在实例化对象中自动调用的，也就是说在类中的所有方法中，只有构造方法是优先调用的，所有使用this调用构造方法必须也只能放在构造方法首行。

　　7、static 关键字

　　　　方法如果是使用static声明的，可以直接使用类名称调用

　　　　非static声明的方法可以去调用static声明的属性或方法，但是static声明的方法是不能调用调用非static类型声明的属性或者方法的。

　　8、代码块

　　　　a、new子类的对象时，先调用父类的static{}里的东西，再调用子类里的static{}，在调用父类{}，在调用父类构造方法，再调用子类构造方法。

　　　　b、调用子类或父类的静态方法时，先调用父类static{}，再调用子类的static{}。

　　　　c、构造块优先于构造方法执行，而且每次实例化对象时都会执行构造块中的代码，会执行多次

　　　　d、静态代码块优先于主方法执行，而在类中定义的静态代码块会优先于构造块执行，而且不管有多少个对象产生，静态代码块只执行一次。

　　9、构造方法的私有化

class Singleton{
    private static Singleton instance = new Singleton();
    private Singleton{}
    public static Singleton getInstance(){
        return instance;
    }
    public void print(){
        System.out.println("Hello WOrld");
    }
}

public class SingleDemo05{
    public static void main(string args){
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        Singleton s3 = Singleton.getInstance();
        s1.print();
        s2.print();
        s3.print();
    }
}

　　程序的意义：以上程序虽然声明了3个Singleton对象，但是实际上所有的对象都只使用一个instance引用。

10、对象数组

　　对象数组就是指包含一组相关对象的集合

　　数组一定要先开辟空间，但是因为其是引用数据类型，所以数组中的每一个对象默认值都是null值，则在使用时数组中的每一个对象都必须分别进行实例化操作。

　　（1）对象数组的声明：

　　　　动态初始化：类 对象数组的名称[] = new 类[数组长度];

　　　　静态初始化：类 对象数组的名称[] = {new 类(), ...., ...., ....}

11、内部类

//内部类的声明格式
标识符 class 外部类的名称{
    //外部类的成员
    标识符class内部类的名称{
        //内部类成员
    }
}

　　注意：1~7行均属于外部类

　　内部类唯一的好处就是可以方便的访问外部类中的私有属性。

　　（1）使用static定义内部类

　　　　使用static可以声明属性或者方法，而使用static也可以声明内部类，用static声明的内部类变成了外部类，但是用static 声明的内部类不能访问非static的外部类属性。

　　（2）在外部类访问内部类

　　　　外部类.内部类 内部类对象 = 外部类实例.new 内部类()；

　　　　提示：内部类定义之后，生成的class文件是以Outer$Inner.class的形式存在的，在Java中只要在文件中存在$，则在程序中应将其替换为“ . ”。

class Outer{                                //定义外部类
    private String Info = "hello world!";
    class Inner{                            //定义内部类
        public void print(){
            System.out.println(Info);        //访问外部类的私有属性
        }
    }
}

public class InnerClassDemo04{
    public static void main(String args[]){
        Outer out = new Outer();            //实例化外部类对象
        Outer.Inner in = out.new Inner();    //实例化内部类对象
        in.print();                            //调用内部类方法
    }
}

　　（3）在方法中定义内部类

　　　　可以在方法中定义一个内部类，但是在方法中定义的内部类不能直接访问方法中的参数，如果方法中的参数要想被内部类所访问，则参数前必须加上final关键字。