java-形参 返回值 成员(匿名)内部类

引言
返回值问题、返回值问题、权限修饰符以及内部类的相关概念,其中,内部类需要重点理解。
形式参数问题
数据类型:
基本类型:byte,short,int,long,float,double,char,boolean
引用类型:类,接口,数组
形式参数:
基本类型:要的是该基本类型的数据值。
引用类型:要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)
B:类 要的是该类或者其子类的对象。(地址值)
C:抽象类 要的是该抽象类的子类对象。(地址值)
D:接口 要的是该接口的实现类对象。(地址值)
举其中一个例子:

//数组 要的是该数据类型数组的对象。(地址值)
public class ArgsStu01 {
    public static void main(String[] args) {
        int[] arr={1,5,3,2,6};
        printArr(arr);
    }
    public static void printArr(int[] arr){
        for(int i=0;iout.print(arr[i]+" ");
        }
    }
}

再写一个抽象类的相关例子:

public class ArgsStu02 {
    public static void main(String[] args) {
        PersonStu ps=new PersonStu();
        Person s=new Student();
        ps.function(s);
    }
}
abstract class Person{
    public abstract void eat();
}
class Student extends Person{
    @Override
    public void eat() {
        System.out.println("大多数学生喜欢吃米饭");
    }
} 
class PersonStu{
    public void function(Person s){
        s.eat();
    }
}

返回值问题
返回值:
基本类型:byte,short,int,long,float,double,char,boolean
引用类型:类,接口,数组
返回值之基本类型:
基本类型:返回的是该基本类型的数据值。
返回值之引用类型:
返回值是类名:其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名:要的是该抽象类的子类对象。(地址值)
返回值是接口名:要的是该接口的实现类对象。(地址值)
在这里,举一个返回值类型是接口名的简例:

interface Inter{
    public abstract void jumpCat();
}
class Cat implements Inter{
    @Override
    public void jumpCat() {
        System.out.println("猫会跳高");
    }
}
class InterStu{
    public Inter method(){
        Inter c=new Cat();
        return c;

    }
}
public class ArgsStu03 {
    public static void main(String[] args) {
        InterStu is=new InterStu();
        Inter c2=is.method();
        c2.jumpCat();
    }
}

权限修饰符
权限修饰符:在哪种情况下可以被访问到。
java-形参 返回值 成员(匿名)内部类_第1张图片
下面举一个在同一个类中的权限修饰符的访问特点:

public class Fu {
    public static void main(String[] args) {
        //调用下面的四个方法
        Fu f = new Fu();
        f.show();
        f.show2();
        f.show3();
        f.show4();
    }
    //使用public修饰的show()
    public void show(){
        System.out.println("public");
    }
    //使用private修饰的show2()
    private void show2(){
        System.out.println("private");
    }
    //默认修饰符修饰的show3()方法
    void show3(){
        System.out.println("默认修饰符");
    }
    //使用protected修饰的show4()
    protected void show4(){
        System.out.println("protected");
    }
}

编译运行结果为:
public
private
默认修饰符
protected
常见的修饰:
类:public
public class HelloWorld {}
成员变量:private
private String name;
private int age;
构造方法:public
public Student() {}
public Student(String name,int age) {}
成员方法:public
public void show() {}
public void eat() {}
有关权限修饰符还有一个知识点需要注意,如下图:
java-形参 返回值 成员(匿名)内部类_第2张图片
注意:
四种权限修饰符,只能有一种存在。
常见的组合:
类:
public class HelloWorld {}
public final class HelloWorld {}
public abstract class HelloWorld {}
成员变量:
private String name;
public final int X = 10;
public static int y = 20;
public static final int X = 30;
成员方法:
public void show(){}
public abstract void show();
public final void show(){}
public static void show() {}
public static final void show() {}
内部类
有关内部类的相关知识点是一个比较难理解的地方,特别是对于我这个初学者,因此,有关的概念必须清晰明了,相关代码也必须多多练习。
内部类:
把类A定义在类B的内部,类A就被称为内部类。
访问特点:
A:内部类可以直接访问外部类的成员,包括私有。
B:外部类要访问内部类的成员,必须创建对象。
例如下面代码所示:

//外部类
class Outer{
    private int num=10;
    //内部类
    class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    //外部类的一个方法
    public void method(){
        Inner i=new Inner();
        i.show();
    }
}
public class InnerStu01 {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

编译yun运行结果为:
10
内部类分类:
成员位置:成员内部类
局部位置:局部内部类
成员内部类:
外界如何创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
有关成员内部类创建对象举一个简单的例子:

//成员内部类
class Outer2{
    class Inner{
        public void show(){
            System.out.println("这是一个成员内部类");
        }
    }
}
public class InnerStu02 {
    public static void main(String[] args) {
        //外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer2.Inner oi=new Outer2().new Inner();
        oi.show();  
    }
}

成员内部类的修饰:
A:private 为了我们访问数据的安全性
B:static 为了我们访问数据的方便性
局部内部类:
A:可以直接访问外部类的成员,包括私有
B:在成员方法中创建局部内部类的对象,调用局部内部类的功能
局部内部类访问局部变量必须加final修饰!!!
因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
下面用一个例子说明:

//  局部内部类
class Outer3{
    private int num=20;
    public void show(){
         final int num=30;
         //内部类
         class Inner3{
             public void method(){
                 System.out.println(num);
             }
         }
         Inner3 i=new Inner3();
         i.method();
    }
}
public class InnerStu03 {
    public static void main(String[] args) {
        Outer3 oi=new Outer3();
        oi.show();
    }
}

编译运行后输出:
30
匿名内部类
没有名字的局部内部类,就是内部类的简化写法
前提:
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式:
new 类名或者接口名() {
重写方法;
};
本质:
是一个继承了类或者实现了接口的子类匿名对象。
举一个简单的例子:

//匿名内部类
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗都喜欢啃骨头");
    }
}
class AnimalStu{
    public void show(Animal a){
        a.eat();
    }
}
public class InnerStu04 {
    public static void main(String[] args) {
        AnimalStu as=new AnimalStu();
        as.show(new Dog());
        as.show(new Animal(){
            public void eat() {
                System.out.println("动物也有不吃肉的");
            }
        });
    }
}

编译运行后结果为:
狗都喜欢啃骨头
动物也有不吃肉的

你可能感兴趣的:(java语言)