- 不同修饰符混合使用细节
- 辨析何时定义变量为成员变量
- 类、抽象类、接口作为方法参数
- 类、抽象类、接口作为方法返回值
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;
}
}