第五章，面向对象基础篇

5.3 封装性
　　• 为了解决属性必须封装且又必须访问的矛盾，只要是被封装的属性，必须通过setter和getter方法设置和取得。
　　• 为前面类的私有属性加上getter和setter方法

Public void setAge（int a）｛
　　Age = a；
｝
Public int getAge（）｛
　　Return age；
｝

setter方法可以加上检测代码检测输入的数据是否合法。

5.4构造方法
　　

Person per = null；声明对象时不调用构造方法。
Per = new Person（）；实例化对象时调用构造方法。

• 构造方法也是可以重载的。只要每个构造方法的参数类型或参数个数不同，即可实现重载。

5.5 匿名对象
匿名对象只在堆内存中开辟空间，而不在栈内存的引用。

new Person("cathy",30).tell(); //匿名对象

5.6 实例讲解

class Student｛
　　private String stuno；
　　public Student（）｛
　　　　public Student（String stuno）｛
　　　　　　this.setStuno(stuno);
　　　　｝
　　｝
　　public float sum(){
　　　　return math+english;
　　}
　　public float avg(){
　　　　return this.sum/3;
　　}
｝ 

5.7 String
• ==是用来进行地址比较的
Str2 str3指向同一个空间，他们的地址值就是相同的。
内容比较用equals，

str2.equals（str3）
“hello”.equals("hello")，一个字符串可以调用string类中的方法，说明一个字符串就是一个string类的匿名对象。

• String str1 = “hello”；

使用这种方式定义字符串有一个好处，就是如果一个字符串已经被一个名称所引用，则以后再有相同的字符串声明时，就不会再重新开辟空间。

String str2 = “hello”； str2==str1.
java中有个字符串池。这种设计叫共享设计，设计思路是，对象池中保存多个对象，新实例化的对象如果已经在池中定义了，则不再重新定义，指向已存在的实例空间。
使用new关键字，无论如何都会重新开一个空间。
对于字符串，就直接赋值，不要采用new。

• 字符串的内容一旦声明不可改变。
非要改变就用stringbuffer类。

• String (char[] value)字符数组变字符串。这是一个构造方法
char[] toCharArray() 字符串变字符数组。这是一个普通方法
char charAt（int index）字符串中取出指定位置字符
int length（）字符串长度
String trim() 清除左右两端空格
String[] split(String regex) 按指定字符串拆分 

IO操作中经常会遇到字符串与byte数组或char数组之间的转换操作。

• length取得数组的长度。
length（）取得字符串的长度。

5.8 引用传递及基本应用

　　1.引用传递

public class RefDemo02{
    public static void main(String args[]){
        String str1 = "hello" ;            // 实例化字符串对象
        System.out.println("fun()方法调用之前：" + str1) ;
        fun(str1) ;                        // 调用fun()方法
        System.out.println("fun()方法调用之后：" + str1) ;
    }
    public static void fun(String str2){        // 此处的方法由主方法直接调用
        str2 = "MLDN" ;                    // 修改字符串内容
    }
};

 程序运行结果

fun()方法调用之前：hello
fun()方法调用之后：hello

因为字符串的内容一旦声明是不可改变的，改变的只是其内存地址的指向。

class Demo{
    String temp = "hello" ;        // 此处为了方便，属性暂时不封装
};
public class RefDemo03{
    public static void main(String args[]){
        Demo d1 = new Demo() ;    // 实例化Demo对象，实例化之后里面的temp=30 
        d1.temp = "world" ;        // 修改temp属性的内容
        System.out.println("fun()方法调用之前：" + d1.temp) ;
        fun(d1) ;
        System.out.println("fun()方法调用之后：" + d1.temp) ;
    }
    public static void fun(Demo d2){        // 此处的方法由主方法直接调用
        d2.temp = "MLDN";                        // 修改temp值
    }
};

 

　　2.接收本类的引用

class Demo{                        // 定义Demo类
    private int temp  = 30 ;    // 声明temp属性并封装
    public void fun(Demo d2){    // 接收本类的引用
        d2.temp = 50 ;            // 直接通过对象调用本类的私有属性
    }
    public int getTemp(){        // getter
        return temp ;
    }
    public void setTemp(int t){    // setter
        temp = t ;
    }
};
public class RefDemo04{
    public static void main(String args[]){
        Demo d1 = new Demo() ;    // 实例化Demo对象
        d1.setTemp(50) ;        // 只能通过setter方法修改内容
        d1.fun(d1) ;            // 此处把Demo的对象传回到自己的类中
        System.out.println("temp = " + d1.getTemp()) ;
    }
};

　　3.person类中可以有一个书属性，这个属性可以是book类。book类中可以有主人属性，这个属性可以是person类

class Person{            // 定义Person类
    private String name ;    // 姓名
    private int age ;        // 年龄
    private Book book ;        // 一个人有一本书
　　 private Person child；      //一个人一个孩子，person类有一个属性，值是另一个person类。
    public Person(String name,int age){
        this.setName(name) ;
        this.setAge(age) ;
    }
    public void setName(String n){
        name = n ;
    }
    public void setAge(int a){
        age = a ;
    }
    public String getName(){
        return name ;
    }
    public int getAge(){
        return age ;
    }
    public void setBook(Book b){
        book = b ;
    }
    public Book getBook(){
        return book ;
    }
};
class Book{                // 定义Book类
    private String title ;    // 标题
    private float price ;    // 价格
    private Person person ;    // 一本书属于一个人
    public Book(String title,float price){
        this.setTitle(title) ;
        this.setPrice(price) ;
    }
    public void setTitle(String t){
        title = t ;
    }
    public void setPrice(float p){
        price = p ;
    }
    public String getTitle(){
        return title ;
    }
    public float getPrice(){
        return price ;
    }
    public void setPerson(Person p){
        person = p ;
    }
    public Person getPerson(){
        return person ;
    }
};
public class RefDemo05{
    public static void main(String arg[]){
        Person per = new Person("张三",30) ;
        Book bk = new Book("JAVA SE核心开发",90.0f) ;
        per.setBook(bk) ;        // 设置两个对象间的关系，一个人有一本书
        bk.setPerson(per) ;        // 设置两个对象间的关系，一本书属于一个人
　　　　 System.out.println("从人找到书 --> 姓名：" + per.getName()+"；年龄：" 
            + per.getAge() +"；书名：" + per.getBook().getTitle() + "；价格：" 
            + per.getBook().getPrice()) ;    // 可以通过人找到书
        System.out.println("从书找到人 --> 书名：" + bk.getTitle() + "；价格："
            + bk.getPrice() + "；姓名：" + bk.getPerson().getName() + "；年龄："
            + bk.getPerson().getAge()) ;    // 也可以通过书找到其所有人
    }
};

　　　　

5.9 this 关键字

　　　　1.可以使用this强调本类中的方法

　　2.表示类中的属性

public Person（String name）{
　　name=name；
}
Vs.
public Person（String name）{
　　This.name=name；
}

3.调用本类的构造方法

如果一个类中有多个构造方法，可以利用this关键字互相调用。

　　

public Person(){
    System.out.println("一个新的Person对象被实例化。")
}
public Person(String name, int age){
    this();
    this.name = name;
}          

使用this调用构造方法必须也只能放在构造方法的第一行。

this调用构造方法是一定要留一个构造方法作为出口，即程序中至少存在一个构造方法不使用this调用其他构造方法。

一般都将无参构造方法作为出口。

　　　　4.表示当前对象

　　　　　　

class Person{
    public Person(){
        pass
    }  
    public boolean compare(Person per){
        Person p1 = this;
        Person p2 = per;
        //person对象中有一个方法compare，可以用传进来的per对象和当前对象作对比
    }
}        

 

 5.10 static 关键字

　　1.java中常用的内存区域

• • 栈内存空间：保存所有的对象名称（更准确的说是保存了引用的堆内存空间的地址）
  • 堆内存空间：保存了每个对象的具体属性内容
  • 全局数据区：保存static类型的属性
  • 全局代码区：保存所有的方法定义

　　2.类属性调用

　　　　类名称.static属性

　　　　Person.country = "b city"　

　　3.使用static声明方法

public static String getCountry(){
    return country;
}

4.使用static属性统计一个类产生了多少个实例化对象

5.使用static为对象进行自动的编名操作

6.程序中的System.exit(1)表示系统退出，只要在exit()方法中设置一个非零的数字，则系统执行到此语句之后将退出系统。

7.如果一个方法要由主方法直接调用，则必须按以下格式声明：“punlic static 方法的返回值类型，方法名称（参数列表）{}”。因为主方法是静态方法，而静态方法是不能调用非静态方法的，所以之前的方法声明处才必须加上static关键字。

 

5.11 代码块

　　1.普通代码块

　　2.构造块

　　　　构造块是直接写在类中的代码块，构造块优先于构造方法执行，每次实例化对象都会执行构造块中的代码。

class Demo{
    {
        System.out.println("定义构造块")；
    }
    public Demo(){
        System.out.println("构造方法")；
    }
}    

 　　3.静态代码块

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

class Demo{
    static{
        System.out.println("静态代码块")；
    }
}

　　　　静态代码块的妙用：静态代码块优先于主方法执行，那么就可以直接使用静态代码块而不使用主方法向屏幕上打印hello world了。成功打印hello world后，会爆找不到主方法的异常。解决办法是，在程序输出完hello world之后直接让程序退出即可。

5.12 构造方法私有化

　　1.对构造方法进行封装

　　　　

class Singleton{
    private Singleton(){
    }//此处将构造方法进行封装
}
public class SingleDemo02{
    public static void main(String args[]){
        Singleton s1 = null; //可以声明对象
        s1 = new Singleton();//错误，无法实例化
    }
}

　　 解决方法

class Singleton{
    //在内部产生本类的实例化对象，将属性封装
    private static Singleton instance = new Singleton();
    private Singleton(){ //将构造方法封装
    }
    public static Singleton getInstance(){ //通过静态方法取得Singleton类的实例
        return instance；
    }
}

public class demo{
　　public static void main(String args[]){
　　　　Singleton s1 = Singleton.getInstance();
　　　　Singleton s2 = Singleton.getInstance();　　　
　　}
}

 instance,s1,s2 都指向同一个堆内存，不管有多少个对象，实际上只有一个实例。

在设计模式中将这样的设计成为单例设计模式，及无论程序怎样运行，Singleton类永远只会有一个实例化对象存在。

5.13 对象数组　　
　　1.对象数组的声明
　　　　类 对象数组名称[] = new 类[数组长度]；

Person per[] = new Person[3];
per[0] = new Person("cathy");
per[1] = new Person(“tom”)；　

//分别为数组中的每个元素初始化，每一个都是对象，都需要单独实例化。

//声明一个对象数组，里面有三个对象，使用静态初始化方式
Person per[] = {new Person("张三"），new Person("李四")，new Person("王五")}；

 5.14 内部类

　　1.使用static定义内部类

　　　　用static定义的内部类变成了外部类，用static声明的内部类不能访问非static的外部类属性。（在实际应用中用的不多，但是不代表没有价值。http://bbs.csdn.net/topics/350021609）

　　　　内部类的第一个好处就体现出来了——隐藏你不想让别人知道的操作，也即封装性。
　　　　内部类的第二个好处——一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！　　　

　　2.在外部访问内部类

　　　　外部类.内部类 内部类对象 = 外部类.new 内部类（）；　　　　
　　　　Outer.Inner in = out.new Inner();　　　　　

　　3.在方法中定义内部类

　　　　　　在方法中定义的内部类不能直接访问方法中的参数，如果方法中的参数想要被内部类所访问，参数钱必须加上final关键字。

　　　　　　

class Outer{        // 定义外部类
    private String info = "hello world" ;    // 定义外部类的私有属性
    public void fun(final int temp){        // 定义外部类的方法
        class Inner{                        // 在方法中定义的内部类
            public void print(){                // 定义内部类的方法
                System.out.println("类中的属性：" + info) ;        // 直接访问外部类的私有属性
                System.out.println("方法中的参数：" + temp) ;
            }
        };
        new Inner().print() ;                // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo05{
    public static void main(String args[]){
        new Outer().fun(30) ;    // 调用外部类的方法
    }
};

实例

　　如果觉得分析类有困难，可以先把基本功能做完，做完之后对一些输入的数据进行验证，再把主方法中的代码尽可能减少，然后再去考虑代码的可重用性。

本章要点

　　如果一个对象没有被实例化而直接使用，则使用时会出现空指向异常。

　　类属于引用数据类型。进行引用传递时，传递的是堆内存的使用权。

　　使用构造方法实例化string时产生两个实例化对象，其中一个是垃圾空间。

　　如果需要限制类对象的产生可以将构造方法私有化。一旦将构造方法私有化，在类的外部就不能new新对象，只能在类的内部创建好一个对象然后调用这个对象。这样就限制了对象的产生。

　　对象数组的使用要分为声明数组和为数组开辟空间两步。开辟空间后数组中的每个元素的内容都是null。

　　在方法中声明的内部类要想访问方法的参数，则参数前必须加上final关键字。因为方法的变量属于局部变量，离开该方法，变量就失去了作用，也就会自动被消除，内部类却不会离开所在方法是就失去作用。