码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2020-04-21 22:29:11      阅读:90      评论:0      收藏:0      [点我收藏+]

标签:特点   编译   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(公共的)

本类下 本包下 外包的子类下 外包下
public
protected ×
default × ×
private × × ×

修饰符:

  • 权限修饰符: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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!