javase笔记day10

方法参数传递和返回值问题

类名作为形式参数

	当你以后看到一个方法的形参，要一个类 类型（引用类型）你就传递一个该类的对象。
     
    引用类型传递，形参的改变会影响实参 属于引用传递，传递的是地址值

public class MyTest {
    public static void main(String[] args) {

        Student student = new Student();
        test(student,30);
        
        student.setNum(student,100);
        System.out.println(student.num); //100
    }
    public static void test(Student student,int num){
        student.num=num;
    }
}

class Student{
    int num=20;
    public void setNum(Student student,int num){
        student.num=num;
    }
}

抽象类名作为形式参数

当你以后看到一个方法的形参要一个 抽象类 类型，你就传递一个该抽象类的子类对象。

public class MyTest {
    public static void main(String[] args) {
        MySon mySon = new MySon();
        test(mySon,2000);
        System.out.println(mySon.num);
        
        MyClass myClass = new MySon();//多态
        test(myClass,1000);
        
        System.out.println(myClass.num);
       

    }
    public static void  test(MyClass myClass,int num){
        //多态的形式
        myClass.num=num;
    }
}

abstract class MyClass{
    int num=20;
    public abstract void show(int num);
}

class MySon extends MyClass{
    int num=200;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

class CC extends MyClass{
    @Override
    public void show(int num) {

    }
}

接口名作为形式参数

当你以后看到一个方法的形参，要一个接口类型，你就传递一个该接口的子类对象。

class MyTest {
    public static void main(String[] args) {
        AA aa = new AA();
        test(aa);
        aa.show();//200
        System.out.println(MyInterface.num); //200

        System.out.println(AA.num);
        aa.show();

        test(new BB());
    }
    public static void test(MyInterface myInterface){
        System.out.println(myInterface.num);//200
    }
}

interface MyInterface{
    int num=200;
    void show();
}
class AA implements MyInterface{

    @Override
    public void show() {
        System.out.println(this.num);
    }
}

class BB implements MyInterface{

    @Override
    public void show() {

    }
}

类名作为返回值类型

当你以后看到一个返回值类型，是一个 类 类型，你就返回一个该类的对象。

public class MyTest {
    public static void main(String[] args) {
        Student student=test(100);
        int num = student.num;
        System.out.println(num);//100
    }
    public static Student test(int num){
        Student student = new Student();
        student.num=num;
        return student;
    }
}
class Student{
    int num=20;
}

抽象类名作为返回值类型

当你以后看到一个方法的返回值类型，是一个抽象类 类型，你就返回一个该抽象类的子类对象。

public class MyTest {
    public static void main(String[] args) {
        MyClass myClass = test(800);
        System.out.println(myClass.num); //200
        //向下转型
        MySon son= (MySon) myClass;
        System.out.println(son.num); //800
    }

    public static MyClass test(int num){
        MySon mySon = new MySon();
        mySon.num=num;
        return mySon;
    }
}
abstract class MyClass {
    int num=200;
    public abstract void show(int num);
}

class MySon extends MyClass{
    int num=2;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

接口名作为返回值类型

如果你以后看到一个方法的返回值类型，是一个接口类型，你就返回一个该接口的子类对象。

public class Mytest {
    public static void main(String[] args) {
        Son son = new Son();
        MyInterface myInterface=test(son);
        son.hehe();
        System.out.println(son.num);//8000
        System.out.println(MyInterface.num); //200
        System.out.println("=======================");
        System.out.println(myInterface.num); //200
        //向下转型
        Son s= (Son) myInterface;
        System.out.println(s.num); //6
    }
。
    public static MyInterface test(MyInterface myInterface){
        //System.out.println(myInterface.num);
        Son son = new Son();
        son.num=6;
        return son;
    }
}
interface MyInterface{
   public static final int num=200;
    void hehe();
}

class Son implements MyInterface{
    int num=600;
    @Override
    public void hehe() {
        this.num=8000;
    }
}

四种权限修饰符

	本类	同一个包下(子类和无关类)	不同包下(子类) 不同包下(无关类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

匿名内部类

内部类：
		就是将一个类A 定义到另一个类B的 内部，我们把类A叫做内部类，把类B叫做外部类

根据类A定义在外部类的位置不同，分为成员内部类和局部内部类
       成员内部类：定义在外部类的成员位置（类中方法外）
       局部内部类：定义在外部类的成员方法中

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
       
    }
}
//外部类
class B{
    //成员内部类
    class A {

    }
    public void show(){
        //局部内部类
        class C{

        }
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        B.A b = new B().new A();//new出访问内部类对象
        b.neiMethod();//调

        B b1 = new B();
        b1.waiMethod();
        b1.show();


        //访问静态内部类
        B.staticNei bs = new B.staticNei();
        bs.staticNeiMethod();
    }
}
//外部类
class B{
    //成员内部类
    int a = 19;
    private int x = 48;
    public void waiMethod(){
        System.out.println("外部类方法");
    }
    class A {
        public void neiMethod(){
            System.out.println("内部类方法");

//内部类可以直接访问外部类的成员，包括私有成员。
            System.out.println(a);
            System.out.println(x);
        }

    }
    public void show(){
        //局部内部类


        class C{
            public void juNeiMethod(){
                System.out.println("局部内部类方法");

            }
        }
    }

    static class staticNei{
        public void staticNeiMethod(){
            System.out.println("静态内部类方法");
        }
    }
}

输出结果

内部类方法
19
48
外部类方法
静态内部类方法