java修行之路（三）

二、面向对象

1.面向对象思想的落地法则

(1)设计类并设计类的成员（成员变量、成员方法）。
(2)通过类，来创建类的对象（实例化）。
(3)通过"对象.属性" 或 "对象.方法"来调用，完成相应的功能。

2.类的属性
(1)成员变量 VS 局部变量

相同点：

   a、遵循变量声明的格式：数据类型 变量名 = 初始化值
   b、都有作用域

不同点：

 a、声明的位置不同。
    成员变量：声明在类里，方法外。
    局部变量：声明在方法内，方法的形参部分，代码块内。
 b、成员变量的修饰符有四个：public private protected  缺省
    局部变量 没有修饰符
 c、成员变量有默认值，不必要显示的初始化赋值。
    局部变量没有默认值，要进行初始化赋值。
 d、在内存中存放的位置不同：
    成员变量：存在于堆空间中，局部变量：栈空间中

3.类的方法（提供某种功能的实现）

(1)格式
    权限修饰符 返回值类型 （void:无返回值/具体的返回值）方法名(形参){
     程序代码
     return 返回值;
    }
(2)关于返回值类型：
    void:表示此方法不需要返回值
    有返回值的方法 return + 返回值类型对应的变量。

(3)方法中的一些概念
    形式参数：在方法被调用时用于接收外部传入的数据的变量。
    参数类型：就是该形式参数的数据类型。
    返回值：方法在执行完毕后返还给调用它的程序的数据。
    返回值类型：方法要返回的结果的数据类型。
    实参：调用方法时实际传给函数形式参数的数据。

(4)方法的重载(overload)
    a、在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
    b、重载示例：
    //返回两个整数的和
      int add(int x,int y){return x+y;}
    //返回三个整数的和
      int add(int x,int y,int z){return x+y+z;}
    //返回两个小数的和
      double add(double x,double y){return x+y;}
(5)方法的重写(override)
    前提：有子类继承父类
    子类继承父类后，若父类的方法对子类不适用，那么子类可以对父类的方法进行重写。
    子类方法的"返回值类型 方法名 (参数列表)"于父类的方法一样

(4)可变个数的形参的方法(JDK1.5新特性)
    a、可变参数：方法参数部分指定类型的参数个数是可变多个
    b、声明方式：方法名（参数的类型名...参数名）
    c、可变参数方法的使用与方法参数部分使用数组是一致的
    d、方法的参数部分有可变形参，需要放在形参声明的最后
    （放在第一个的化，如果这个可变参数，传递的个数是0个就会发生错误）

//示例代码：
写一个类，此类提供一个求多个数的和方法。

        //一般用方法的重载
        public  int getSum(int x,int y){
           return x + y;
        }
        public  int getSum(int x,int y,int z){
            return x + y + z;
        }
        //传递一个数组
        public  int getSum(int[] args){
            int sum = 0;
            for (int i = 0; i < args.length; i++) {
                sum += args[i]; 
            }
            return sum;
        }
        //可变个数的形参 可以传递一个或多个参数
        public  int getSum(int ... args){
            int sum = 0;
            for (int i = 0; i < args.length; i++) {
                sum += args[i]; 
            }
            return sum;
        }

4.构造器(构造方法)

(1)构造器的特征
    它具有与类相同的名称
    它不声明返回值类型。（与声明为void不同）
    不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
(2)构造器的作用
    创建对象；给对象进行初始化
    例如：Order o = new Order();    Person p = new Person(Peter,15)
(3)语法格式
    修饰符  类名 (参数列表) {
        初始化语句；
    } 
(4)根据参数不同，构造器可以分为如下两类
    隐式无参构造器（系统默认提供）
    显式定义一个或多个构造器（无参、有参）
(5)注意：
    默认构造器的修饰符与所属类的修饰符一致
    一旦显式定义了构造器，则系统不再提供默认构造器
    一个类可以创建多个重载的构造器
    父类的构造器不可被子类继承

5.权限修饰符

(1)Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。
(2)对于class的权限修饰只可以用public和default(缺省)

图 5-1

6.关键字 this、super

(1)this 
    a、可以用来修饰属性、方法、构造器
    b、this理解为当前对象或当前正在创建的对象。
    c、可以在构造器中通过“this(形参)” 的方式显式的调用本类中其他重载的指定的构造器。
    d、当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员(否则参数传过来，赋给成员变量为初始值)

示例代码：

class Person{       // 定义Person类
        private String name ;       
        private int age ;           
        public Person(){      // 无参构造
            System.out.println("新对象实例化") ;
        }
        public Person(String name){
            this();      // 调用本类中的无参构造方法
            this.name = name ;  
        }
        public Person(String name,int age){ 
            this(name) ;  // 调用有一个参数的构造方法
            this.age = age;
        }
        public String getInfo(){    
            return "姓名：" + name + "，年龄：" + age ;
        } 
        public static void main(String[] args) {
            Person person = new Person("xue");
            String s = person.getInfo();
            System.out.println(s);

            Person person1 = new Person("jiang",20);
            String s1 = person1.getInfo();
            System.out.println(s1);

            //新对象实例化
            //姓名：xue，年龄：0
            //新对象实例化
            //姓名：jiang，年龄：20
        }
    }

(2)super
    a、可以用来修饰属性、方法、构造器
    b、当子类与父类中有同名的属性时，可以通过"super.属性"显示的调用父类中声明的属性。若想调用子类同名的属性"this.属性"
    c、当子类重写父类的方法之后，在子类中调用父类中被重写的方法，使用"super.方法"
    d、super可用于在子类构造方法中调用父类的构造器
    注意：
     子类中所有的构造器默认都会访问父类中空参数的构造器。
     当父类中没有空参数的构造器时，子类的构造器必须通过  this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行。
     在设计类时，最好提供一个空参的构造器，不然子类写空参构造器时会报错

示例代码：

//父类
    public class Person {
        private String name;
        private  int age;
        int id = 1001;

        public Person(){
            this.name = "xue";
            this.age = 20;
        }

        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 int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }
        public void eat(){
            System.out.println("吃饭");
        }
        public void sleep(){
            System.out.println("睡觉哦");
        }
    }
    //子类
    public class Student extends Person {
        private int id = 1002;

        public Student() {
            super(); //调用父类的构造器
        }

        public void eat() {  //重写eat方法
            System.out.println("学生吃饭");
        }

        public void show() {
            String name = getName();
            System.out.println(name);//xue

            int age = getAge();
            System.out.println(age);//20

            System.out.println(super.id);  //1001 调父类的属性 id
            System.out.println(this.id);    //1002 调本类的属性 id
            super.eat();  //吃饭      调父类的方法 eat
            this.eat();   //学生吃饭  调本类的方法 eat
            sleep(); //前面使用super或者this都可以，因为这个方法没有重写
        }
    }
    //测试类
    public class TestStudent {
        public static void main(String[] args) {
            //Student类被实例化时，创建构造器，此构造器通过super调用父类构造器
            Student student = new Student(); 
            student.show();
        }
    }

7.面向对象的特性

(1)封装性
   a、给类的属性，设置权限修饰符private,设置此修饰符后，该类实例化，不能直接访问属性 对象.属性
   b、使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作。

(2)继承
    a、通过 "class A extends B"类实现类的继承（子类 A 父类 B）
    b、子类继承父类后，父类中声明的属性和方法，子类就可以获取的到
    c、extends: 子类是对父类功能的扩展，子类可以有自己的属性、方法。
    d、单继承： 一个类只能继承一个父类。
    e、一个父类可以有多个子类

示例代码：

        //定义一个父类
        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 void sleep(){
                System.out.println("睡觉哦");
            }
        }
        public class Man extends Person { // Man类继承Person类
            public static void main(String[] args) {
                Man man = new Man();
                man.sleep(); //睡觉哦
            }
            //方法的重写
            public void sleep(){
                System.out.println("失眠了");
            }
        }

(3)多态性 
    多态性可以理解为一个事物的多种表现形态。
    方法的重载和重写 

示例代码：

        //定义一个父类
        public class Person {
            private String name;
            private int age;

            public Person() {

            }

            public Person(String name, int age) {
                this.name = name;
                this.age = 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 void shopping(){
                System.out.println("购物");
            }
        }
        //定义一个子类
        public class Man extends Person {
            private  int id;

            public Man() {

            }

            public Man(int id,String name,int age) {
                super(name,age);
                this.id = id;
            }

            public int getId() {
                return id;
            }

            public void setId(int id) {
                this.id = id;
            }

            public void  shopping(){
                System.out.println("男人购物");
            }

            public void  smoking(){
                System.out.println("男人抽烟");
            }

        }
        //测试类
        public class TestPerson {
            public static void main(String[] args) {
                //子类对象的多态性：父类的引用指向子类对象
                Person man = new Man(); //向上转型
                //虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写的方法。
                man.shopping(); //男人购物
                //子类所特有的属性和方法不能调用
                //man.smoking();

                Man man1 = (Man)man;//向下转型  跟基本数据类型的转化有异曲同工之妙
                man1.smoking(); //男人抽烟

            }

        }

(4)多态性的应用举例

示例代码：

public class TestAnimal {
            public static void main(String[] args) {
                TestAnimal test = new TestAnimal();
                test.show(new Cat());

            }
            public void show(Animal a){
                a.eat();
                a.sleep();

                if(a instanceof Dog){  //判断a是否是Dog对象的实例
                    Dog dog = (Dog)a;
                    dog.dogMethod();
                }else if(a instanceof Cat){
                    Cat cat =(Cat)a;
                    cat.catMethod();
                }
            }
            //如果不用多态性，将要创建多个方法
        //    public void show(Dog a){
        //        a.eat();
        //        a.sleep();
        //    }
        //
        //    public void show(Cat a){
        //        a.eat();
        //        a.sleep();
        //    }
        }

        class Animal{
            private String name;
            private int age;

            public void eat(){
                System.out.println("进食");
            }

            public void sleep(){
                System.out.println("睡觉");
            }
        }

        class Dog extends Animal{

            public void eat(){
                System.out.println("狗吃骨头");
            }

            public void sleep(){
                System.out.println("狗睡觉");
            }

            public void dogMethod(){
                System.out.println("call 汪汪汪");
            }
        }

        class Cat extends Animal{

            public void eat(){
                System.out.println("猫吃鱼");
            }

            public void sleep(){
                System.out.println("猫睡觉");
            }

            public void catMethod(){
                System.out.println("call 喵喵喵");
            }
        }