11、面向对象（类、抽象类、接口作为方法的参数类型和返回值类型、链式编程、package、import关键字、成员内部类（静态内部类））

标签：特点   编译   default   多级   方法   lan   表示   文件   不同   

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

类名作为形式参数的类型

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/4/21 17:28
 */
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        //如果方法的形参是一个类类型，传递一个该类的对象
        setNum(student, 20);
        System.out.println(student.num);
        //20
        student.setNum(30);
        System.out.println(student.num);
        //30
    }

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

class Student {
    int num = 10;

    public void setNum(int num) {
        this.num = num;
    }
}

抽象类名作为形式参数的类型

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/4/21 17:32
 */
public class MyTest2 {
    public static void main(String[] args) {
        //当方法的形参类型是一个抽象类类型，那么需要传递抽象类的子类对象
        SpecificClass specificClass = new SpecificClass();
        show(specificClass, 1000);
        System.out.println(specificClass.num);
        //子类的num属性不变
        //100
    }

    public static void show(AbstractClass abstractClass, int num) {
        abstractClass.num = num;
        //多态方式访问成员变量，编译看左，运行看左，所以修改的是抽象类的num属性
    }
}

abstract class AbstractClass {
    int num = 10;

    /**
     * 抽象show方法
     * @param num num
     */
    public abstract void show(int num);
}

class SpecificClass extends AbstractClass {
    int num = 100;

    @Override
    public void show(int num) {
        this.num = num;
    }
}

接口名作为形式参数的类型

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/4/21 17:39
 */
public class MyTest3 {
    public static void main(String[] args) {
        //当方法的形参类型是一个接口时，需要传递一个接口的实现类对象
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        show(myInterface);
        System.out.println(MyInterface.NUMBER);
        //10
        System.out.println(MyInterfaceImpl.NUMBER);
        //10
    }

    public static void show(MyInterface myInterface) {
        myInterface.show();
        //10
        //多态形式访问成员方法，编译看左边，运行看右边
    }
}

interface MyInterface {
    int NUMBER = 10;

    /**
     * show()
     */
    void show();
}

class MyInterfaceImpl implements MyInterface {

    @Override
    public void show() {
        //不推荐this访问静态变量，但是可以执行
        System.out.println(MyInterface.NUMBER);
    }
}

类名作为返回值类型

package org.westos.demo1;

/**
 * @author lwj
 * @date 2020/4/21 20:18
 */
public class MyDemo {
    public static void main(String[] args) {
        Student student=test(100);
        int num = student.num;
        System.out.println(num);
        //100
    }

    /**
     * 方法的返回值类型是一个类类型，那么返回一个该类的对象
     * @param num num属性
     * @return 返回该类的对象
     */
    public static Student test(int num){
        Student student = new Student();
        student.num=num;
        //100
        return student;
    }
}

class Student {
    int num = 20;
}

抽象类名作为返回值类型

package org.westos.demo1;

/**
 * @author lwj
 * @date 2020/4/21 20:21
 */
public class MyDemo2 {
    public static void main(String[] args) {
        AbstractClass abstractClass = test(800);
        System.out.println(abstractClass.num);
        //200
        //多态的形式访问成员变量，编译看左，运行看左
        
        
        //向下转型
        AbstractClassImpl son= (AbstractClassImpl) abstractClass;
        System.out.println(son.num);
        //800
    }

    /**
     * 方法的返回值类型是一个抽象类，那么返回该抽象类的一个子类对象
     * @param num num
     * @return 返回值
     */
    public static AbstractClass test(int num){
        AbstractClassImpl impl = new AbstractClassImpl();
        impl.num=num;
        return impl;
    }
}

abstract class AbstractClass {
    int num=200;

    /**
     * 抽象show()
     * @param num num
     */
    public abstract void show(int num);
}

class AbstractClassImpl extends AbstractClass{
    int num=2;

    @Override
    public void show(int num) {
        this.num=num;
    }
}

接口名作为返回值类型

package org.westos.demo1;

/**
 * @author lwj
 * @date 2020/4/21 20:25
 */
public class MyDemo3 {
    public static void main(String[] args) {
        MyInterfaceImpl son = new MyInterfaceImpl();
        MyInterface myInterface=test(son);
        //方法的参数是接口，传递接口的实现类对象son，son.num = 600
        //test()返回新对象impl，impl.num = 6
        son.show();
        System.out.println(son.num);
        //8000
        

        //向下转型
        MyInterfaceImpl s= (MyInterfaceImpl) myInterface;
        System.out.println(s.num);
        //6
    }

    /**
     * 方法的返回值类型是一个接口，那么需要返回该接口的实现类对象
     * @param myInterface
     * @return
     */
    public static MyInterface test(MyInterface myInterface){
        System.out.println(MyInterface.NUMBER);
        //200
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.num=6;
        return impl;
    }
}

interface MyInterface{
    int NUMBER = 200;

    /**
     * 抽象show
     */
    void show();
}

class MyInterfaceImpl implements MyInterface{
    int num=600;

    @Override
    public void show() {
        this.num = 8000;
    }
}

链式编程

package org.westos.demo2;


/**
 * @author lwj
 * @date 2020/4/21 20:25
 */
public class MyTest {
    public static void main(String[] args) {
        //链式编程：当调用完一个方法后，这个方法返回一个对象，那么我就可以打点，再去调用这个对象里面的方法。
        Student student = new Student();
        test().getStudent(student,2000).show();
        //调用的是student对象的show()方法，但是this.num = num，更新的是test()方法返回的对象
        
        System.out.println(student.num);
        //20
        //getStudent()是谁调用修改谁的num属性，并不是参数student的num属性被修改
    }
    public static Student test(){
        return new Student();
    }
}

class Student{
    int num=20;
    public Student getStudent(Student student,int num){
        this.num=num;
        return student;
    }
    public void show(){
        System.out.println("show 方法");
    }
}

包的定义、package、import关键字

包，就是文件夹，用来解决同一文件夹下不能存在同名文件的问题。

定义包的格式：

package 包名;

多级包名之间用.分开即可。

定义包的注意事项：

• package语句必须是程序的第一条可执行代码
• package语句在一个.java文件中只能有一个
• 如果没有package，默认表示无包名

导包的格式：

import 包名;

package org.westos.demo1;

import java.util.Scanner;

/**
 * @author lwj
 * @date 2020/4/21 19:51
 */
public class MyTest {
    public static void main(String[] args) {
        //ctrl + alt + o: 优化导包,没有导入的包自动导入,没有用到的包自动移除import语句
        new Scanner(System.in);
    }
}

package org.westos.demo1;


/**
 * @author lwj
 * @date 2020/4/21 19:51
 */
public class MyTest {
    public static void main(String[] args) {
        //ctrl + alt + o: 优化导包,没有导入的包自动导入,没有用到的包自动移除import语句
        java.util.Scanner scanner = new java.util.Scanner(System.in);
    }
}

package在import之前，import在class之前。

权限修饰符

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

修饰符：

• 权限修饰符：private、默认的、protected、public
• 状态修饰符：static、final
• 抽象修饰符：abstract

修饰类的关键字：

• 权限修饰符：默认的、public
• 状态修饰符：final
• 抽象修饰符：abstract

修饰成员变量的关键字：

• 权限修饰符：private、默认的、protected、public
• 状态修饰符：static、final

修饰构造方法的关键字：

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

修饰成员方法的关键字：

• 权限修饰符：private、默认的、protected、public
• 状态修饰符：static、final
• 抽象修饰符：abstract

成员内部类

内部类概述：把一个类定义在其他类的内部，这个类就被称为内部类。

举例：在类A中定义了一个类B，类B就是内部类。

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/4/21 21:44
 */
public class MyTest {
    public static void main(String[] args) {
        //内部类：就是将一个类A 定义到另一个类B的 内部，我们把类A叫做内部类，把类B叫做外部类
        //根据类A定义在外部类的位置不同，分为成员内部类和局部内部类
        //成员内部类：定义在外部类的成员位置（类中方法外）
        //局部内部类：定义在外部类的成员方法中
    }
}

/**
 * 外部类
 */
class Outer {
    /**
     * 成员内部类
     */
    class Inner {

    }

    public void method() {
        /**
         * 局部内部类
         */
        class LocalInner {
            
        }
    }
}

内部类访问特点：

• 内部类可以直接访问外部类的成员，包括私有成员
• 外部类要访问内部类的成员，必须创建对象

按照内部类位置分类：

• 成员位置：在成员位置定义的类，被称为成员内部类
• 局部位置：在局部位置定义的类，被称为局部内部类

成员内部类：

格式：外部类名.内部类名 对象名 = new 外部类名().new 内部类名()；

package org.westos.demo2;

/**
 * @author lwj
 * @date 2020/4/21 21:47
 */
public class MyTest {
    public static void main(String[] args) {
        //内部类的特点
        //1.内部类可以直接访问外部类的成员，包括私有成员。

        //在测试类里面要去调用内部类的成员变量和成员方法
        //1.创建成员内部类的对象的语法
        Outer.Inner inner = new Outer().new Inner();
        System.out.println(inner.integer);
        //20
        inner.innerShow();

        
        //2、通过访问外部类方法，间接访问内部类成员
        Outer outer = new Outer();
        outer.outerTest();
    }
}

class Outer {
    int num = 200;
    private double decimal = 3.24;

    public void outerShow() {
        System.out.println("外部类的show方法");
    }

    /**
     * 定义成员内部类
     */
    class Inner {
        int integer = 20;

        public void innerShow() {
            System.out.println("内部类的show方法");
            System.out.println(integer);
            System.out.println(num);
            //访问外部类的成员,包括私有成员
            System.out.println(decimal);
            outerShow();
        }
    }

    /**
     * 外部类访问内部类，必须创建内部类对象
     */
    public void outerTest() {
        Inner inner = new Inner();
        System.out.println(inner.integer);
        inner.innerShow();
    }
}

成员内部类的特殊修饰符：

• private
• static

package org.westos.demo3;

/**
 * @author lwj
 * @date 2020/4/21 21:57
 */
public class MyTest {
    public static void main(String[] args) {
        //创建内部类的对象
        //Wai.Nei nei = new Wai().new Nei(); 内部类私有后，这个语法就创建不出来内部类对象
        Outer outer = new Outer();
        outer.outerDemo();
    }
}

class Outer {
    int a = 20;
    private int b = 10;

    public void outerShow() {
        System.out.println("wai show");
    }

    private void outerTest() {
        System.out.println("外部类私有方法");
    }

    /**
     * 定义成员内部类
     * 内部类可以访问外部类的成员包括私有
     * private 可以修饰内部类 私有的内部类，外界不能创建其对象了。
     */
    private class Inner {
        int c = 233;

        public void neiShow() {
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
            outerShow();
            outerTest();
        }
    }

    public void outerDemo() {
        Inner inner = new Inner();
        System.out.println(inner.c);
        inner.neiShow();
    }
}

package org.westos.demo4;

/**
 * @author lwj
 * @date 2020/4/21 22:03
 */
public class MyTest {
    public static void main(String[] args) {
        //创建静态内部类对象,Outer后面没有()
        Outer.Inner inner = new Outer.Inner();
        inner.neiShow();
    }
}

class Outer {
    private int num = 100;
    private static double decimal = 3.25;

    public void outerShow() {
        System.out.println("外部类show方法");
    }

    public static void outerStaticShow() {
        System.out.println("静态的外部类show方法");
    }

    /**
     * 内部类可以使用static来修饰
     * 静态内部类，只能访问外部类的静态成员，静态内部类，在成员的位置，相当于成员方法，所以只能访问静态成员，不能访问实例成员
     */
    public static class Inner {
        int c = 20;

        public void neiShow() {
            System.out.println(c);
            //System.out.println(num);
            //outerShow(); 非静态成员，在静态内部类中不能访问
            System.out.println(decimal);
            outerStaticShow();
            //在静态内部类中，只能访问外部类的静态成员
        }
    }
}

成员内部类面试题

package org.westos.demo5;

/**
 * @author lwj
 * @date 2020/4/21 22:13
 */
public class MyTest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

class Outer {
    public int num = 10;
    int b = 2002;

    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(Inner.this.num);
            //20
            System.out.println(new Outer().num);
            //10
            System.out.println(Outer.this.num);
            //10
            System.out.println(Outer.this.b);
            //2002
            System.out.println(b);
            //2002
        }
    }
}

成员内部类

• 权限修饰符：public、protected、缺省、private
• 状态修饰符：static

11、面向对象（类、抽象类、接口作为方法的参数类型和返回值类型、链式编程、package、import关键字、成员内部类（静态内部类））

标签：特点   编译   default   多级   方法   lan   表示   文件   不同   

原文地址：https://www.cnblogs.com/shawnyue-08/p/12748400.html