javase学习第10天

形式参数和返回值类型、包、内部类、匿名内部类

形式参数：值传递

基本类型：将实参的值复制一份传给形参

引用类型：将实参的引用传递给形参，将导致形参和实参都指向同一个实例对象。

返回值类型

基本类型：返回的是一个基本数据类型的值；

引用类型：返回的是一个对象的引用。

链式编程

当一个方法的返回值是引用类型的时候，它返回的是一个对象的引用，那么就可以直接在此基础上访问这个对象的方法，当被调用的方法的返回值依然是一个引用 的话，还可继续再调用所返回对象的方法。

当形参为抽象类时：返回的是该抽象类的实现子类的对象；

形参为接口，返回的是该接口实现类的对象；

类名作为返回值，返回的是该类的实例对象。

包 package

为了避免同名类过多而产生混乱，在类前加上额外的限定；

作用：可对类进行分类管理，格式通常是公司域名倒写，在后面加上项目名等。

-cp 指明所依赖的包及运行的类的目录（即类路径，包所在路径），彼此之间用“；”分开；

-d表明生成带包类的层次目录，会在指定目录下，自动创建出和包结构相对应的目录，并将生成的.class类文件放入到最里面的文件夹中。

在使用带包的类时，必须使用完整类名（包名+类名）来访问。

定义格式

package 包名： 包名只要是有效的标识符即可，通常使用小写字母，多级包用“.”分开即可，一个圆点代表一个文件夹。

注意事项

1、package语句必须是程序的第一条可执行代码，前面有注释没有影响。

2、pacekage语句在一个java文件中只能有一个；

3、一旦定义了包。则类的使用的时候就用包名.类名的方式。

4、执行顺序：package-->import -->class

package只能有一个，并且必须是文件的第一条可执行语句； import：在类之前，并且可以有多个；

类成员权限

类及成员所用修饰符：

类：

1、四种权限中可以使用两种（默认的，public），final，abstract

2、我们自己定义：public居多

成员变量：

1、四种权限修饰符均可,final,static

2、我们自己定义：private居多

构造方法：

1、四种权限修饰符均可,其他（final，static）不可

2、我们自己定义：public 居多

成员方法：

1、四种权限修饰符均可，fianl,static,abstract

2、我们自己定义：public居多

内部类

把类定义在其他类的内部，这个在其他类里面的类就是内部类。

内部类的访问特点

1、内部类可以直接访问外部类的成员，包括私有；

2、外部类要访问内部类的成员，必须通过创建内部类对象来完成。

内部类位置

两种格式： 成员位置（成员内部类）；局部位置（局部内部类）；

成员内部类分为两种：

1、private修饰的私有成员内部类：只能通过在外部类中定义公有方法对私有内部类进行访问，否则不能直接访问私有的成员内部类。

2、static静态成员内部类：直接通过外部类名.内部类名来访问。

1 int num = 10;
2 static int num2 = 20;
3 public static class Heart {
4     // int a = num;    //外部类的非静态成员不能访问
5         int b = num2;        //OK，只能访问外部类的静态成员
6     }

被静态修饰的成员内部类只能访问外部类的静态成员；不能访问外部类的非静态成员；但可以有静态非静态方法，都只能访问外部类的静态成员；

1、外界访问静态内部类的方法：

1 Outer.Inner ii = new Outer.Inner();
2
3 ii.func1(); 

不能用 Outer.Inner oi = new Outter().new Inner();

2、非静态成员内部类（如用public修饰的）： 只能定义非静态方法、非静态变量，但可以访问外部类的静态和非静态成员；

 1 class Outer{
 2     int num1 = 1;
 3     static int num2 = 10;
 4     public class Inner{
 5         //static int age = 18;//error非静态成员内部类不能定义静态成员变量
 6         public Inner(){}
 7         /*void func1(){
 8             System.out.println(num1);
 9             System.out.println(num2);
10         }*/            //OK，非静态成员内部类只能定义非静态方法
11         /*
12         static void func1(){
13             System.out.println(num1);
14             System.out.println(num2);
15         }
16         */            //error，非静态成员内部类不能定义静态方法
17     }
18 }

局部内部类

可以直接访问外部类的成员；

可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能。

 1 class Outer {
 2     private int num  = 10;
 3
 4     public void method() {
 5         //int num2 = 20;
 6         //final int num2 = 20;
 7         class Inner {
 8             public void show() {
 9                 System.out.println(num);
10                 System.out.println(num2);
11             }
12         }
13         //System.out.println(num2);
14         Inner i = new Inner();
15         i.show();        //？这样写有点麻烦，有没有简便写法？
16     }
17 }
18
19 class InnerClassDemo5 {
20     public static void main(String[] args) {
21         Outer o = new Outer();
22         o.method();
23     }
24 }

匿名内部类

前提，存在一个类或者接口

格式 ：new 类名或者接口名（）{重写（实现）方法；}

本质：是一个继承了类或者实现了接口的子类匿名对象。

 1 interface Person{
 2     public abstract void show();
 3 }
 4 //非匿名方式
 5 class Student implements Person{
 6     public void show(){
 7         System.out.println("students show");
 8     }
 9 }
10 class PersonDemo{
11     public Person test(Person p){
12         p.show();
13         return p;
14     }
15 }
16 class InterDemo{
17     public static void main(String[]args){
18         PersonDemo pd=new PersonDemo();
19         Student s=new Student();
20         // pd.test(s);
21         pd.test(new Person(){
22             public void show(){
23                 System.out.println("ni ming");
24             }
25         });//匿名内部类
26     }
27 }