Java基础知识 12（接口，参数传递，返回值类型，链式编程，面向对象修饰符，内部类）

最新推荐文章于 2024-04-15 00:55:21 发布

骑着蜗牛行天下

最新推荐文章于 2024-04-15 00:55:21 发布

阅读量230

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_45447369/article/details/105722417

版权

Java基础专栏收录该内容

42 篇文章 0 订阅

订阅专栏

Java基础知识 12

面向对象之接口

接口：定义接口，interface接口里面就可以定义一个可以扩展的功能，将来有哪些事物，想要具备这些功能，就可以来实现这个接口，然后重写这个功能。
接口不能创建对象。 FireInterface f=new FireInterface;    //报错
子类————实现implement————FireInterface接口
使用多态的形式来调用子类重写过的方法。           父接口指向子类对象
接口的特点：（1）接口中只能定义常量，还是公共的静态常量，不能是变量。
		 （public static final）int NUM=200;  （public static final）默认存在
		  （2）接口中没有构造方法。
		  （3）接口中的全部都是抽象方法，没有非抽象方法。
		  （public abstract）void hehe();		（public abstract）默认存在
类和类之间的关系：继承关系，并且是单继承，支持多层继承。
类和接口之间的关系：实现关系，并且可以多实现，一个类可以实现多个接口。
一个类在继承一个父类的时候还可以去实现多个接口。
接口和接口之间的关系：一个接口可以继承多个接口，继承关系，可以单继承，也可以多继承。
抽象类和接口之间的区别：（1）抽象类中，可以定义成员变量和定义常量。
					（2）接口中定义的都是公共的静态常量。
					（3）抽象类中有构造方法，接口中没有构造方法这一说。
					（4）抽象类中，既可以定义抽象方法，也可以定义非抽象方法。

参数传递

案例程序分析1：

1.当你以后看到一个方法的形参，要一个类 类型（引用类型），你就传递一个该类的对象。
2.引用类型的传递，形参会影响实参，属于引用传递，传递的是地址值。
public class Mytest{
    public static void main(String[] args) {
        //参数传递
        //当你以后看到一个方法的形参，要一个类 类型（引用类型）你就传递一个该类的对象。
        //引用类型传递，形参的改变会影响实参 属于引用传递，传递的是地址值。
        Student student = new Student();
        test(student,30);
        System.out.println(student.num);//30
        test(new Student(),60);//匿名对象作为形参，
        System.out.println(student.num);//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;
    }
}

案例程序分析2：

3.当你以后看到一个方法的形参要一个抽象类 类型，你就传递一个该抽象类的子类对象。
public class Mytest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参要一个 抽象类 类型，你就传递一个该抽象类的子类对象。
        MYson mYson = new MYson();
        test(mYson,300);
        System.out.println(mYson.num);//200
        test(new MYson(),400);
        System.out.println(mYson.num);//200
        test(new CC(),500);
        System.out.println(mYson.num);//200
    }
    public static void test(Myclass myclass,int num){
        //父类引用，采用多态形式，访问的是父类的num。只会将父类中的100覆盖掉，此十输出的是子类的num.
        myclass.num=num;
    }
}
abstract class Myclass{
    int num=100;
    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) {

    }
}

案例程序分析3：

4.当你以后看到一个方法的形参，要一个接口类型，你就传递一个该接口的子类对象。
public class Mytest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参，要一个接口类型，你就传递一个该接口的子类对象。
        AA aa = new AA();
        test(aa);
        aa.show();
        System.out.println(AA.num);
        System.out.println(MyInterface.num);
        aa.show();
        test(new AA());
    }
    public static void test(MyInterface myInterface){
        System.out.println(myInterface.num);
    }
}
interface MyInterface{
    int num=100;
    void show();
}
class AA implements MyInterface{
    @Override
    public void show() {
        System.out.println(this.num);
    }
}
class BB implements MyInterface{
    @Override
    public void show() {

    }
}

返回值类型

案例程序分析4：

1.当你以后看到一个返回值类型，是一个类 类型，你就返回一个该类的对象。
public class Mytest {
    public static void main(String[] args) {
        //当你以后看到一个返回值类型，是一个 类 类型，你就返回一个该类的对象。
        Student test = test(100);
        int num=test.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;
}

案例程序分析5：

2.当你以后看到一个方法的返回值类型是一个抽象类 类型，你就返回一个该抽象类的子类对象。
public class Mytest {
    public static void main(String[] args) {
        Myclass myclass = test(300);//多态
        System.out.println(myclass.num);
        //向下转型
        Myson myson = (Myson) myclass;//300覆盖了子类的200，即输出300
        System.out.println(myson.num);
    }
    //当你以后看到一个方法的返回值类型是一个抽象类型，那么返回一个该抽象类的子类对象。
    public static Myclass test(int num){
        Myson myson = new Myson();
        myson.num=num;
        return myson;
    }
}
abstract class Myclass{
    int num=100;
    public abstract void show(int num);
}
class Myson extends Myclass{
    int num=200;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

案例程序分析6：

3.当你以后看到一个方法的返回值类型是一个接口类型，你就返回该接口的一个子类对象。
public class Mytest {
    public static void main(String[] args) {
        Myson myson = new Myson();
        MyInterface myInterface = test(myson);
        myson.show();
        System.out.println(myson.num);//1000
        System.out.println(myInterface.num);//100//多态
        System.out.println("----------------------------");
        Myson myson1= (Myson) myInterface;//向下转型
        System.out.println(myson1.num);//300
    }
    //如果你以后看到一个方法的返回值类型，是一个接口类型，你就返回一个该接口的子类对象。
    public static MyInterface test(MyInterface myInterface){
        Myson myson = new Myson();
        myson.num=300;
        return myson;
    }
}
interface MyInterface{
    public static final int num=100;
    void show();
}
class Myson implements MyInterface{
    int num=200;
    @Override
    public void show() {
        this.num=1000;
    }
}

链式编程

案例程序分析7：

链式编程：当调用完一个方法后，这个方法返回一个对象，那么我就可以打点，再去调用这个对象里面的方法。
public class Mytest {
    public static void main(String[] args) {
        Student student1=test();
        Student student2=student1.getstudent(student1,5000);
        student1.show();//show方法
        System.out.println(student1.num);//5000
        Student student = new Student();
        test().getstudent(student,1000).show();
        System.out.println(student.num);//show方法  1000
        test().getstudent(student,500).show();
        System.out.println(student.num);//show方法  500
    }
    //链式编程:当调用完一个方法后，这个方法返回一个对象，那么我就可以打点再去调用这个对象里面的方法。
    public static Student test(){
        Student student = new Student();
        return student;
    }
}
class Student{
    int num=20;
    public Student getstudent(Student student,int num){
        student.num=num;
        return student;
    }
    public void show(){
        System.out.println("show方法");
    }
}

导包

1.类与类之间的访问权限：
		    	本类	 同一个包下（子类和无关类）	不同包下（子类）	不同包下（无关类）
private 	     Y				
缺省的			 Y				Y							
protected		 Y				Y							Y
public			 Y				Y							Y				Y
2.不同包的类之间访问时，需要导包，基本语法：import +包名地址.包名（系统会自动调用）
3.快捷方法：Ctrl +Alt+o,导包优化，会删除多余包或者增加未导入的包
4.导包的语句位于class之外。导包也可以在创建对象时，将包的地址放到类名之前就不用导包了。

面向对象修饰符

（1）修饰符： 权限修饰符：private，默认的，protected，public
			状态修饰符：static，final 
			抽象修饰符：abstract
（2）修饰类的关键字：权限修饰符：默认修饰符，public
			 	  状态修饰符：final
			 	  抽象修饰符：abstract
		用的最多的就是：public
（3）修饰成员变量的关键字：	权限修饰符：private，默认的，protected，public
				   		 状态修饰符：static，final
		用的最多的就是：private
（4）修饰构造方法的关键字：	权限修饰符：private，默认的，protected，public
		用的最多的就是：public
（5）修饰成员方法的关键字：	权限修饰符：private，默认的，protected，public
				    	 状态修饰符：static，final
				   		 抽象修饰符：abstract
		用的最多的就是：public
（6）除此以外的组合规则：
	成员变量：public static final 
	成员方法：public static 
	         public abstract
			 public final

内部类

内部类，就是将一个类A定义到另一个类B的内部，我们把A叫做内部类，类B叫做外部类。
根据类A定义在内部类的位置不同，分为成员内部类和局部内部类。
成员内部类：定义在外部类的成员位置（类中方法外）
局部内部类：定义在外部类的成员方法中
在测试类里面要去调用内部类的成员变量和成员方法。

根据类A定义在内部类的位置不同，分为成员内部类和局部内部类。
成员内部类：定义在外部类的成员位置（类中方法外）
局部内部类：定义在外部类的成员方法中
在测试类里面要去调用内部类的成员变量和成员方法。

案例程序分析8：

创建成员内部类：
1.内部类可以直接访问外部类的成员，包括私有成员。
2.外部类想要访问内部类的成员，要创建内部类对象。
public class Mytest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        System.out.println(inner.a);
        inner.neishow();
        System.out.println("-------------------");
        Outer outer = new Outer();
        outer.waiTest();
    }
}
class Outer{
    int num=200;
    private double b=3.14;
    class Inner{
        int a=100;
        public void neishow(){
            System.out.println("内部类的show方法");
            System.out.println(a);
            //内部类可以直接访问外部类的成员，包括私有成员。
            System.out.println(b);
            System.out.println(num);
        }
    }
    public void show(){
        System.out.println("外部类中的show方法");
    }
    //外部类想要访问内部类的成员
    public void waiTest(){
        Inner inner = new Inner();
        System.out.println(inner.a);
        inner.neishow();
    }
}

案例程序分析9：

定义成员内部类：
1.内部类可以直接访问外部类的成员，包括私有成员。
2.private可以修饰内部类，私有的内部类，外界不能再创建其对象了。
但是我们可以在与内部类同级的方法中创建内部类对象，然后可以调用其中的成员变量和方法。
public class Mytest {
    public static void main(String[] args) {
        //Wai.Nei nei = new Wai().new Nei();//内部类私有后，此语法失效。
        Wai wai = new Wai();
        wai.neisi();
    }
}
class Wai{
    int num=10;
    private int b=100;
    public void waishow(){
        System.out.println("waishow方法");
    }
    private void siyou(){
        System.out.println("外部类的私有方法");
    }
    //定义成员内部类
    //内部类可以直接访问外部类的成员包括私有
    //pirvate 可以修饰内部类 私有的内部类，外界不能创建其对象了。
    private class Nei{
        int c=1000;
        public void neishow(){
            System.out.println(num);//10
            System.out.println(b);//100
            waishow();//waishow方法
            siyou();//外部类的私有方法
        }
    }
    public void neisi(){
        Nei nei = new Nei();
        System.out.println(nei.c);//1000
        nei.neishow();
    }
}

案例程序分析10：

1.静态内部类的创建语句:Wai.Nei nei = new Wai.Nei();
内部类可以用static修饰，静态内部类只能访问外部类的静态对象。
2.在内部类中，如果访问外部类的成员变量，在有重名的情况下，可以使用这样的语法：
System.out.println(Outer.this.num);
System.out.println(Outer.this.b);
-----------------------------------------------------------
public class Mytest {
    public static void main(String[] args) {
        //静态内部类的创建语法：
        Wai.Nei nei = new Wai.Nei();
        nei.neishow();
    }
}
class Wai{
    static int a=10;
    private static double num=3.14;
    private static void waishow(){
        System.out.println("waishow方法");
    }
    public static void waishow2(){
        System.out.println("waishow2方法");
    }
    //静态的内部类只能访问静态的变量
    public static class Nei{
        int c=100;
        public void neishow(){
            waishow();
            waishow2();
            System.out.println(a);
            System.out.println(num);
        }
    }
}
----------------------------------------------------------------
public class Mytest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}
class Outer{
    public int num=100;
    int b=500;
    class Inner{
        public int num=1000;
        int b=600;
        public void show(){
            int num=2000;
            System.out.println(num);//2000
            System.out.println(this.num);//1000
            System.out.println(new Inner().b);//600
            System.out.println(new Outer().b);//500
            //你要在内部类中，访问外部类的成员变量。有重名的情况下，可以使用下面的语法
            System.out.println(Outer.this.num);//100******记住这个语法
            System.out.println(Outer.this.b);//500
            System.out.println(b);//600 
        }
    }
}