14-面向对象

• 不同修饰符混合使用细节
• 辨析何时定义变量为成员变量
• 类、抽象类、接口作为方法参数
• 类、抽象类、接口作为方法返回值

1 不同修饰符使用细节

常用来修饰类、方法、变量的修饰符如下：

• public权限修饰符，公共访问类，类，方法，成员变量
• protected权限修饰符，受保护访问，方法，成员变量。
• 默认什么也不写，也是一种权限修饰符，默认访问，类，方法，成员变量。
• private权限修饰符，私有访问，方法，成员变量。
• static 静态修饰符，类，方法，成员变量，局部变量
• final 最终修饰符，类，方法，成员变量，局部变量
• abstract 抽象修饰符，类，方法

我们编写程序时，权限修饰符一般放于所有修饰符之前，不同的权限修饰符有时不能同时使用。

abstract与private不能同时使用
abstract与static不能同时使用
abstract与final不能同时使用

• 修饰"类"能够使用的修饰符：
  修饰类只能使用public、默认的、final、abstract关键字，使用最多的就是public关键字。

public class Demo{} //最常用的方式
class Demo2{}
public final class Demo3{}
public abstract class Demo4{}

• 修饰"成员变量"能够使用的修饰符：

public： 公共的
protected：受保护的
    ：默认的
private：私有的
final：最终的 
static：静态的
使用最多的是 private
//例
public int count = 100;
projtected int count2 =100;
int count3 = 100;
private int count4 = 100;//最常用的方式
public final int count5 = 100;
public static int count6 = 100;

• 修饰"构造方法"能够使用的修饰符

public：公共的
protected：受保护的
        ：默认的
private：私有的
使用最多的是：public

//例
public Demo(){}//最常用的方式
protected Demo(){}
Demo(){}
private Demo(){}

• 修饰"成员方法"能够使用的修饰符：

public： 公共的
protected：受保护的
        ：默认的
private：私有的
final：最终的
static：静态的
abstract：抽象的
使用最多的是public

//例
public void method1(){}//最常用的方式
protected void method2(){}
void method3(){}
private void method4(){}
public final void method5(){}
public static void method6(){}//最常用的方式
public abstract void method7(){}//最常用的方式

2 自定义数据类型的使用

2.1 辨析成员变量与方法参数的设计定义

• 定义长方形，包含求周长与求面积的方法
• 定义数学工具类，包含求两个数和的二倍与求两个数积的方法
  思考：这两个类的计算均需要两个参数与计算，请问两个数定义在成员位置还是形参位置更好，为什么？
• 数学工具类

public class MathTool{
//求两个数的和的二倍
public double sum2times(int number,int number2){
      return (number+number2)*2;
  }
//求两个数的积
public double area(int number,int number2){
    return number*number2;
  }
}

• 长方形类

public class CFX{
    //因为长与宽，在现实事物中属于事物的一部分，所以定义成员变量
private int chang;
private int kuan;
public CFX(int chang,int kuan){
      this.chang=chang;
      this.kuan=kuan;
    }
//求长与宽的周长
public double zhouChang(){
         return (chang+kuan)*2;
    }
//求长与宽的面积
public double mianJi(){
        return chang*kuan;
   }
public int getChang(){
        return chang;
  }
public int setChang(int chang){
        this.chang = chang;
  }
public int getKuan(){
        return kuan;
  }
public int setKuan(int kuan){
        this.kuan = kuan;
  }

}

2.2 类作为方法参数与返回值

• 类作为方法参数
  在编写程序中，会经常碰到调用的方法要接收的是一个类类型的情况，那么这时，要向方法中传入该类的对象。如下代码演示：

package itcast01;
//创建一个Person类
public class Person {
    
        public static void main(String[] args) {
            Person p = new Person();
            //调用Person类的方法，传递一个Person类对象
            method(p);
    
        }

        public static void show() {
            System.out.print("类作为方法的参数");
        }
        
        //定义一个方法method，用来接收Person对象，在方法中调用Person的show方法
        public static void method(Person p) {
            p.show();
        }
}

• 类作为方法返回值
  写程序调用方法时，我们以后会经常碰到返回一个类类型的返回值，那么这时，该方法要返回一个该类的对象。如下所示：

package itcast02;
//方法返回类的对象
public class Person {
    public void show() {
        System.out.println("show方法执行了");
    }
}

//测试类
package itcast02;

public class Test {

    public static void main(String[] args) {
        //调用method方法，获取返回的Person对象
        Person p = method();
        p.show();
    }
    
    //定义一个方法，此方法返回Person类的对象
    public static Person method() {
        Person p = new Person();
        return p;
    }

}

2.3 抽象类作为方法参数与返回值

• 抽象类作为方法参数
  抽象类作为方法参数的情况比较常见，当遇到方法参数为抽象类类型时，要传入一个实现了抽象类所有抽象方法的子类对象。如下所示：

package itcast03;
//抽象类作为方法参数
public abstract class Person {
    public abstract void show();

}
//子类
package itcast03;

public class Student extends Person {

    public void show() {
        System.out.println("抽象类作为方法参数，子类重写抽象类方法");
    }
    
}
//测试类
package itcast03;

public class Test {

    public static void main(String[] args) {
        //通过多态的方式创建一个Person类型的变量，而这个对象实际上是Student对象。
        Person p = new Student();
        //调用method方法
        method(p);
    }
    
    //抽象类作为方法的参数
    public static void method(Person p) {
        //调用p方法，实际调用的是Student类的show方法
        p.show();
    }

}

• 抽象类作为方法返回值
  抽象类作为方法返回值的情况也是有的，这时需要返回一个实现抽象类所有抽象方法的子类对象。如下所示

package itcast01;
//抽象类
public abstract class Person {
    //抽象方法
    public abstract void show();
}
package itcast01;
//抽象类的子类，实现了抽象类所有抽象方法的子类
public class Student extends Person{
    public void show() {
        System.out.println("子类重写父类的抽象方法");
    }
}
package itcast01;
//测试类，抽象类作为方法返回值
public class TestDemo {

    public static void main(String[] args) {
        //调用method方法，获取返回的Person对象
        Person p = method();
        //通过p变量调用show方法，这时实际调用的是Student对象中的show方法
        p.show();
        
    }

    
    //定义一个方法，抽象类作为方法返回值
    public static Person method() {
        Person p = new Student();
        return p;
    }
}
输出：
子类重写父类的抽象方法

2.4 接口作为方法参数与返回值

• 接口作为方法参数
  接口作为方法参数的情况是很常见的，经常会碰到。当遇到方法参数为接口类型时，那么该方法传入一个接口实现类对象。如下所示：

package itcast02;
//接口作为方法的返回值
public interface Smoke {
    //定义抽象方法
    public abstract void smoking();
}
package itcast02;
//接口smoke的实现类Student
public class Student implements Smoke{
    //重写抽象方法
    public void smoking() {
        System.out.println("课下一支烟，赛过活神仙！");
    }
}
package itcast02;
//接口作为方法参数
public class TestDemo {

    public static void main(String[] args) {
        //通过多态的方式，创建一个Smoke类型的变量，而这个对象实际是Student
        Smoke s = new Student();
        method(s);
    }

    
    //定义方法，用来接收一个Smoke类型对象，在方法中调用Smoke对象的show方法
    public static void method(Smoke sm) {
        //通过sm变量调用smoking方法，这时实际调用的是Student对象中的smoking方法。
        sm.smoking();
    }
}
输出：
课下一支烟，赛过活神仙！

• 接口作为方法的返回值
  接口作为方法返回值情况，在后面的迭代器中会碰到。当遇到方法返回值是接口类型时，那么该方法需要返回一个接口实现类对象。如下所示

package itcast02;
//接口作为方法的返回值
public interface Smoke {
    //定义抽象方法
    public abstract void smoking();
}
package itcast02;
//接口smoke的实现类Student
public class Student implements Smoke{
    //重写抽象方法
    public void smoking() {
        System.out.println("课下一支烟，赛过活神仙！");
    }
}
package itcast02;
//接口作为方法返回值
public class TestDemo {

    public static void main(String[] args) {
    //调用method方法，获取返回的会吸烟的对象
        Smoke s = method();
        s.smoking();
    }


    //定义一个方法method，用来获取一个具备吸烟功能的对象，并在方法中完成吸烟者的创建
    public static Smoke method() {
        Smoke sm = new Student();
        return sm;
    }
}