java 内部类 返回值_Java之方法参数类型以及返回值问题研究、权限修饰符 、内部类、匿名内部类...

方法参数类型以及返回值问题

1.形式参数是基本类型要的是一个基本类型的变量或者具体的常量值；(1)是类名的时候要的是一个该类的对象；(2)是抽象类名的时候的要的是一个继承自该类的一个子类对象；(3)是接口的时候要的是一个实现了该接口的子类对象；

2.返回值是基本数据类型的时候返回的是一个具体的值；(1)是类名的时候,本质上返回的是一个该类对应的子类对象；(2)是抽象类名的时候返回的应该是一个继承自该类的子类对象；(3)是接口名的时候返回的是一个实现了该接口的子类对象；

3.注意：基本数据类型作为参数传递时，形参的改变不会影响实参，而引用数据类型作为参数传递时，形参的改变会影响实参！！！

链式编程

链式编程就是把多个方法使用点语法链接起来，只要结尾为一个对象就可以继续调用方法；

链式编程的优点：编程性强、可读性强、代码简洁；但是不太利于代码的调试；

普通写法：

Tiger tiger = new Tiger();

Tiger tiger1 = tiger.getTiger(new Tiger(), 10);

int age1 = tiger1.getAge();

链式编程：

int age = new Tiger().getTiger(new Tiger(), 10).getAge();

package、import

package为包的意思，本质为一个文件夹，包可以按照功能或者模块来划分，用来进行分类管理管理；

注意事项:(1)package语句必须是程序的第一条可执行的代码;(2)package语句在一个java文件中只能有一个(3)如果没有package，则默认表示无包名；

import：不同包下类之间的访问；

权限修饰符

四种权限修饰符：private(私有的) , 默认 , protected(受保护的) , public(公共的)

private ：私有的只能在本类使用

默认：可以在本类和同一包下(子类和无关类使用

protected：可以在本类、同一个包下(子类和无关类)、不同包下(子类)

public：可以在所有情况下使用，包括不同包下

A:修饰符：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

B:可以修饰类的修饰符：

权限修饰符：默认修饰符，public

状态修饰符：final

抽象修饰符：abstract

用的最多的就是：public

C:可以修饰成员变量的修饰符：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

用的最多的就是：private

D:可以修饰构造方法：

权限修饰符：private，默认的，protected，public

用的最多的就是：public

E:可以修饰成员方法：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

用的最多的就是：public

F:除此以外的组合规则：

成员变量：public static final

成员方法：public static

public abstract

public final

内部类

内部类：即一个类中包含了另外一个类；

内部类的特点：1.内部类可以直接访问外部类的成员，包括私有；2.外部类要访问内部类的成员必须要创建对象

内部类分类：按照内部类位置分为：成员内部类和局部内部类

访问内部类成员格式：外部类名.内部类名 对象名=外部类对象.内部类对象

public int num = 10;

class Inner {

public int num = 20;

public void show() {

int num = 30;

System.out.println(num);//30

System.out.println(this.num);//20

System.out.println(Outer2.this.num);//10//注意这种语法

}

}

}

class InnerClassTest {

public static void main(String[] args) {

Outer2.Inner oi = new Outer2().new Inner();//直接访问内部类成员

oi.show();

}

}

成员内部类的修饰符：private：为了保证数据的安全性；static：为了方便访问数据；

注意事项：1.静态内部类访问外部类必须是静态的；2.成员方法可以是静态的也可以是非静态的；3.内部类的静态方法使用类名即可调用

成员内部类被静态修饰后的访问方式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

static int num=100;

//static 可以修饰内部类

// 静态内部类只能访问外部类的静态成员

public static class NeiClass{

public void innerShow(){

System.out.println("我是内部类的show方法");

System.out.println(num);

hehe();

}

public static void innerTest(){

System.out.println("我是内部类的静态方法");

}

public void test(){

System.out.println("我是内部类的静态方法");

}

}

public static void hehe(){

System.out.println("我是外部类的静态hehe方法");

//内部类的静态方法,类名就可以调用

NeiClass.innerTest();

//外部类访问内部类的方法，创建内部类对象

NeiClass neiClass = new NeiClass();

neiClass.test();

}

}

public class Test4 {

public static void main(String[] args) {

//创建静态内部类的语法

WaiClass.NeiClass neiClass=new WaiClass.NeiClass();

neiClass.innerShow();

}

}

局部内部类访问局部变量必须使用final修饰；局部内部类可以直接访问外部类的成员；可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

原因：因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

// 成员变量

private int a = 45;

// 成员方法

public void show() {

// 定义一个局部变量

final int b = 45;//JDK1.7之前要加final不然报错 但是在JDK1.8 不用加 不会报错

// 局部内部类

class Inner {

public void method() {

System.out.println(a);

System.out.println(b);

}

}

// 创建对象

Inner i = new Inner();

// 调用方法

i.method();

}

public static void main(String[] args) {

// 创建Outer的对象

Outer out = new Outer() ;

// 调用show方法

out.show() ;

}

}

匿名内部类

匿名内部类：就是局部内部类的简写方法；

匿名内部类的前提：存在一个类或者接口;这里的类可以是具体类也可以是抽象类；

书写格式：new 类名或者接口名{

重写方法；

}

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

public static void main(String[] args) {

//匿名内部类:他是局部内部类的简写方式

//匿名内部类本质是一个对象,是谁的对象呢?是实现了该接口或继承了该抽象类的子类对象

//匿名内部类的语法

new Animal() {

@Override

public void show() {

System.out.println("我重写了show方法");

}

}.show();

testMethod(new Animal() {

@Override

public void show() {

System.out.println("我又重写了show方法");

}

});

// testMethod(new Dog());

}

private static void testMethod(Animal an) {

an.show();

}

}