2021-7-23第十四天

第十四天

形式参数问题

如果方法的形参是引用类型,调用方法的时候传递实际的参数.
如果是具体类,呢么就直接调用该方法,实际参数需要传递当前具体类的对象.
如果是抽象类,调用该方法的时候需要传递的抽象类的子类对象.(抽象类多态)
如果是一个接口,那么调用方法时,实际参数需要传递的是当前借口的子实现类对象.(借口多态)

	//定义一个接口
interface Love{
    void love() ;
}

//LoveDemo类
class LoveDemo {                        //Love love = new LovePerson() p
    public void function(Love l){//方法的形式参数是接口类型,必须传递接口的子实现类对象
        l.love();//love.love() ;
    }
}

//定义一个接口的子实现类
class LovePerson implements  Love{

    @Override
    public void love() {
        System.out.println("爱生活,爱Java,爱高圆圆...");
    }
}
//测试类
public class LoveTest {
    public static void main(String[] args) {
        //需要访问LoveDemo类中的function方法
        //创建LoveDemo类对象
        LoveDemo ld = new LoveDemo() ;
        //Love love  = new Love() ; //接口不能实例化
        //接口多态
        Love love = new LovePerson() ;
        ld.function(love) ;
        System.out.println("------------------------");

        //匿名对象
        new LoveDemo().function(new LovePerson());
    }
}

如果一个方法的返回值是引用类型,方法结束时如何返回?
具体类的方法返回就是放回当前具体类的对象.
抽象类需要返回的是抽象类的子类对象.
接口需要返回的是该接口的子实现类对象

//定义一个接口
//结婚的接口
interface  Mary{
    public abstract  void mary() ;
}
//MaryDemo类
class MaryDemo{
    public Mary function(){//返回值类型是接口类型,
        //return ?

        //  Mary mary = new Mary() ; //接口不能实例化
        //需要提供接口的子实现类对象
        //接口多态
       // Mary mary = new You() ;
       // return mary ;


        //一步走
        return new You() ;
    }
}
//定义一个类
class You implements  Mary{
    @Override
    public void mary() {
        System.out.println("结婚了,很开心...");
    }
}

//测试类
public class LoveTest {
    public static void main(String[] args) {
        //调用MaryDemo类中的function方法?
        MaryDemo maryDemo = new MaryDemo() ;
        Mary mary = maryDemo.function();
        mary.mary();

        System.out.println("----------------------");

        //匿名对象
        Mary m = new MaryDemo().function();
        m.mary();
    }
}

package关键字

包在java中就相当于windows中的文件夹,包的作用就是解决类名重复产生冲突的问题,便于软件的发布.

包的格式: package 包名;
包名的命名规范就是包名全部小写
包语句必须位于java中的第一个语句,import语句要放在package语句下面.
如果一个类加上了暴雨局,呢么该类的完整类名就是包名 类名
一个java文件只能有一个包语句

在编译的时候使用 java -d 指定类文件的存放路径 java源文件

权限修饰符

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

被private修饰后仅能在同一个包的当前类中访问,默认修饰符default可以在当前类和当前类的子类中访问,protected修饰后可以在当前类,同一包下的类中,还有不同包下的类中去访问,public公共可以再前三个所有地方访问,还可以在不同包的无关类中访问.

内部类

就是在一个类中定义了另一个类,
在类A中定义了类B,呢么B就是A的内部类,A就是B的外部类.
内部类可以访问外部类的成员,包括私有的.

//外部类
class Outer{
    //成员变量
    public int num = 100 ;
    private int num2 = 200 ;

    class Inner{ //成员内部类
        //成员内部类的一个成员方法
        public void method(){
            System.out.println("method Inner");
            System.out.println();
            System.out.println(num2);
        }

    }

    //外部类的成员方法
    public void show(){
        //访问的成员内部类的method--->通过创建内部类对象来访问
        //method() ;错误的----访问的本类的method方法
        Inner inner = new Inner() ;
        inner.method();
    }
}

外部类访问内部类成员的方法:

//外部类名.内部类名 对象名 = 外部类对象.内部类对象
class Outer2{
    private int num = 20 ;

    //成员内部类
    class Inner2{
        public void show(){
            System.out.println(num);
        }
    }

    //外部类的成员方法
    public void method(){
        // 创建内部类对象访问内部类的成员方法
    }
}

//测试类
public class InnerClassDemo2 {
    public static void main(String[] args) {

        //外部类名.内部类名  对象名 =  外部类对象.内部类对象;
        //适用于:通过外部类直接访问成员内部类的成员(前提条件:当前成员内部类是一个非静态类)
        Outer2.Inner2 oi = new Outer2().new Inner2() ;
        oi.show() ;
    }
}

一般来说在内部类上加上private,为了数据的安全性,如果要访问内部类的话就要通过外部类的公共方法去进行间接访问.

//外部类直接访问成员内部类的成员
//格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;

如果当前的成员内部是静态的,里面的方法无论是静态还是非静态的,都只能访问外部类的静态成员,包括私有.
想要直接方位静态成员内部类的方法可以通过直接访问类的方式去访问,即:
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

class Outer3{
    //定义非静态的成员变量
    public int num = 50 ;
    private static int num2 = 20 ;

    //定义成员内部类:静态的           ---->静态的成员内部类可以看成是外部类的静态成员
    static class Inner3{//此时类都是静态
        public void show(){
           // System.out.println(num);
            System.out.println(num2);
        }
        public static void show2(){
           // System.out.println(num);
            System.out.println(num2);
        }
    }
}


//测试类
public class InnerClassDemo3 {
    public static void main(String[] args) {


        // 外部类名.内部类名 对象名  = 外部类对象.内部类对象;
        //Outer3.Inner3 oi = new Outer3().new Inner3() ;  适用不了了

        //   外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
        Outer3.Inner3 oi = new Outer3.Inner3() ;
        oi.show();
        oi.show2() ; //静态---不推荐对象名访问

        System.out.println("------------------------------");
        //show2()的另一种方式
        Outer3.Inner3.show2(); //show2()静态方法

    }
}