zoukankan      html  css  js  c++  java
  • java基础之修饰符和内部类

    1、java修饰符
    /*
    修饰符:
    权限修饰符:private,默认的,protected,public
    状态修饰符:static,final
    抽象修饰符:abstract

    类:
        权限修饰符:默认修饰符,public
        状态修饰符:final
        抽象修饰符:abstract
    
        用的最多的就是:public
    
    成员变量:
        权限修饰符:private,默认的,protected,public
        状态修饰符:static,final
    
        用的最多的就是:private
    
    构造方法:
        权限修饰符:private,默认的,protected,public
    
        用的最多的就是:public
    
    成员方法:
        权限修饰符:private,默认的,protected,public
        状态修饰符:static,final
        抽象修饰符:abstract
    
        用的最多的就是:public
    
    除此以外的组合规则:
        成员变量:public static final
        成员方法:public static 
                  public abstract
                  public final
    

    这里写图片描述

    public class Demo {
        //成员变量
        private int x = 10;
        int y = 20;
        protected int z = 30;
        public int a = 40;
        public final int b = 50;
        public static int c = 60;
        public static final int d = 70;
        //此处不允许使用修饰符abstract
        //abstract int e = 80;
    
        //构造方法
        private Demo(){}
    
        Demo(String name){}
    
        protected Demo(String name,int age) {}
    
        public Demo(String name,int age,String address) {}
    
        //此处不允许使用修饰符static
        //public static Demo(){}
        //此处不允许使用修饰符final
        //public final Demo() {}
        //此处不允许使用修饰符abstract
        //public abstract Demo(){}
    
        //成员方法
        //static void show() {}
        //abstract void show();
        //final void show(){}
    }
    /*
        权限修饰符:
                        本类  同一个包下(子类和无关类)   不同包下(子类)    不同包下(无关类)
            private     Y       
            默认      Y       Y
            protected   Y       Y                           Y
            public      Y       Y                           Y               Y
    */
    package com.liuyi;
    
    public class Father {
        private void show() {
            System.out.println("show");
        }
    
        void show2() {
            System.out.println("show2");
        }
    
        protected void show3() {
            System.out.println("show3");
        }
    
        public void show4() {
            System.out.println("show4");
        }
    
        public static void main(String[] args) {
            Father f = new Father();
            f.show();
            f.show2();
            f.show3();
            f.show4();
        }
    }
    package com.liuyi;
    
    public class Son extends Father {
        public static void main(String[] args) {
            Father f = new Father();
            //f.show();
            f.show2();
            f.show3();
            f.show4();
            System.out.println("--------------");
    
            Son s = new Son();
            //s.show();
            s.show2();
            s.show3();
            s.show4();
        }
    }
    package cn.qx;
    
    import com.liuyi.Father;
    
    public class Son2 extends Father {
        public static void main(String[] args) {
            Father f = new Father();
            //f.show();
            //f.show2();
            //f.show3();
            f.show4();
            System.out.println("--------------");
    
            Son2 s = new Son2();
            //s.show();
            //s.show2();
            s.show3();
            s.show4();
        }
    }
    package com.liuyi;
    
    public class Test {
        public static void main(String[] args) {
            Father f = new Father();
            //f.show();
            f.show2();
            f.show3();
            f.show4();
        }
    }
    package cn.qx;
    
    import com.liuyi.Father;
    
    class Test2 {
        public static void main(String[] args) {
            Father f = new Father();
            //f.show();
            //f.show2();
            //f.show3();
            f.show4();
        }
    }

    2、内部类

    /*
    成员内部类的修饰符:
        private 为了保证数据的安全性
        static 为了方便访问数据
            注意:静态内部类访问的外部类数据必须用静态修饰。
    
    案例:我有一个人(人有身体,身体内有心脏。)
    
            class Body {
                private class Heart {
                    public void operator() {
                        System.out.println("心脏搭桥");
                    }
                }
    
                public void method() {
                    if(如果你是外科医生) {
                        Heart h = new Heart();
                        h.operator();
                    }
                }
            }
    
            按照我们刚才的讲解,来使用一下
            Body.Heart bh = new Body().new Heart();
            bh.operator();
            //加了private后,就不能被访问了,那么,怎么玩呢?
            Body b =  new Body();
            b.method();
    */
    class Outer {
        private int num = 10;
        private static int num2 = 100;
    
        //内部类用静态修饰是因为内部类可以看出是外部类的成员
        public static class Inner {
            public void show() {
                //System.out.println(num);
                System.out.println(num2);
            }
    
            public static void show2() {
                //System.out.println(num);
                System.out.println(num2);
            }       
        }
    }
    
    class InnerClassDemo4 {
        public static void main(String[] args) {
            //使用内部类
            // 限定的新静态类
            //Outer.Inner oi = new Outer().new Inner();
            //oi.show();
            //oi.show2();
    
            //成员内部类被静态修饰后的访问方式是:
            //格式:外部类名.内部类名 对象名 = new 外部类名.内部类名();
            Outer.Inner oi = new Outer.Inner();
            oi.show();
            oi.show2();
    
            //show2()的另一种调用方式
            Outer.Inner.show2();
        }
    }
    /*
        成员内部类:
            如何直接访问内部类的成员。
            外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    */
    class Outer {
        private int num = 10;
    
        class Inner {
            public void show() {
                System.out.println(num);
            }
        }
    }
    
    class InnerClassDemo3 {
        public static void main(String[] args) {
            //需求:我要访问Inner类的show()方法
            //Inner i = new Inner();
            //i.show();
    
            //格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;
            Outer.Inner oi = new Outer().new Inner();
            oi.show();
        }
    }
    /*
        内部类概述:
            把类定义在其他类的内部,这个类就被称为内部类。
            举例:在类A中定义了一个类B,类B就是内部类。
    
        内部的访问特点:
            A:内部类可以直接访问外部类的成员,包括私有。
            B:外部类要访问内部类的成员,必须创建对象。
    
    */
    class Outer {
        private int num = 10;
    
        class Inner {
            public void show() {
                System.out.println(num);
            }
        }
    
        public void method() {
            //找不到符号
            //show();
    
            Inner i = new Inner();
            i.show();
        }
    
    }
    
    class InnerClassDemo {
        public static void main(String[] args) {
    
        }
    }
    /*
        内部类位置
            成员位置:在成员位置定义的类,被称为成员内部类。    
            局部位置:在局部位置定义的类,被称为局部内部类。
    
    
        成员位置:在成员位置定义的类,被称为成员内部类。    
    
    */
    class Outer {
        private int num = 10;
    
        //成员位置
        /*
        class Inner {
    
        }
        */
    
    
        public void method() {
            //局部位置
            class Inner {
    
            }
        }
    }
    
    class InnerClassDemo2 {
        public static void main(String[] args) {
    
        }
    }
    /*
        局部内部类
            A:可以直接访问外部类的成员
            B:在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能
    
        面试题:
            局部内部类访问局部变量的注意事项?
            A:局部内部类访问局部变量必须用final修饰
            B:为什么呢?
                局部变量是随着方法的调用而调用,随着调用完毕而消失。
                而堆内存的内容并不会立即消失。所以,我们加final修饰。
                加入final修饰后,这个变量就成了常量。既然是常量。你消失了。
                我在内存中存储的是数据20,所以,我还是有数据在使用。
    */
    class Outer {
        private int num  = 10;
    
        public void method() {
            //int num2 = 20;
            //final int num2 = 20;
            class Inner {
                public void show() {
                    System.out.println(num);
                    //从内部类中访问本地变量num2; 需要被声明为最终类型
                    System.out.println(num2);//20
                }
            }
    
            //System.out.println(num2);
    
            Inner i = new Inner();
            i.show();
        }
    }
    
    class InnerClassDemo5 {
        public static void main(String[] args) {
            Outer o = new Outer();
            o.method();
        }
    }
    /*
        匿名内部类
            就是内部类的简化写法。
    
        前提:存在一个类或者接口
            这里的类可以是具体类也可以是抽象类。
    
        格式:
            new 类名或者接口名(){
                重写方法;
            }
    
        本质是什么呢?
            是一个继承了该类或者实现了该接口的子类匿名对象。
    */
    interface Inter {
        public abstract void show();
        public abstract void show2();
    }
    
    class Outer {
        public void method() {
            //一个方法的时候
            /*
            new Inter() {
                public void show() {
                    System.out.println("show");
                }
            }.show();
            */
    
            //二个方法的时候
            /*
            new Inter() {
                public void show() {
                    System.out.println("show");
                }
    
                public void show2() {
                    System.out.println("show2");
                }
            }.show();
    
            new Inter() {
                public void show() {
                    System.out.println("show");
                }
    
                public void show2() {
                    System.out.println("show2");
                }
            }.show2();
            */
    
            //如果我是很多个方法,就很麻烦了
            //那么,我们有没有改进的方案呢?
            Inter i = new Inter() { //多态
                public void show() {
                    System.out.println("show");
                }
    
                public void show2() {
                    System.out.println("show2");
                }
            };
    
            i.show();
            i.show2();
        }
    }
    
    class InnerClassDemo6 {
        public static void main(String[] args) {
            Outer o = new Outer();
            o.method();
        }
    }
    /*
        面试题:
            要求请填空分别输出30,20,10。
    
        注意:
            1:内部类和外部类没有继承关系。
            2:通过外部类名限定this对象
                Outer.this
    */
    class Outer {
        public int num = 10;
        class Inner {
            public int num = 20;
            public void show() {
                int num = 30;
                System.out.println(num);
                System.out.println(this.num);
                //System.out.println(new Outer().num);
                System.out.println(Outer.this.num);
            }
        }
    }
    class InnerClassTest {
        public static void main(String[] args) {
            Outer.Inner oi = new Outer().new Inner();
            oi.show();
        }   
    }
    /*
        匿名内部类在开发中的使用
    */
    interface Person {
        public abstract void study();
    }
    
    class PersonDemo {
        //接口名作为形式参数
        //其实这里需要的不是接口,而是该接口的实现类的对象
        public void method(Person p) {
            p.study();
        }
    }
    
    //实现类
    class Student implements Person {
        public void study() {
            System.out.println("好好学习,天天向上");
        }
    }
    
    class InnerClassTest2 {
        public static void main(String[] args) {
            //测试
            PersonDemo pd = new PersonDemo();
            Person p = new Student();
            pd.method(p);
            System.out.println("--------------------");
    
            //匿名内部类在开发中的使用
            //匿名内部类的本质是继承类或者实现了接口的子类匿名对象
            pd.method(new Person(){
                public void study() {
                    System.out.println("好好学习,天天向上");
                }
            });
        }
    }
    /*
        匿名内部类面试题:
            按照要求,补齐代码
                interface Inter { void show(); }
                class Outer { //补齐代码 }
                class OuterDemo {
                    public static void main(String[] args) {
                          Outer.method().show();
                      }
                }
                要求在控制台输出”HelloWorld”
    */
    interface Inter { 
        void show(); 
        //public abstract
    }
    
    class Outer { 
        //补齐代码
        public static Inter method() {
            //子类对象 -- 子类匿名对象
            return new Inter() {
                public void show() {
                    System.out.println("HelloWorld");
                }
            };
        }
    }
    
    class OuterDemo {
        public static void main(String[] args) {
            Outer.method().show();
            /*
                1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
                2:Outer.method().show()可以看出method()方法的返回值是一个对象。
                    又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
            */
        }
    }

    3、总结

    4:权限修饰符(掌握)
     (1)权限修饰符
                    本类   同一个包下  不同包下的子类   不同包下的无关类
        private      Y
        默认          Y         Y
        protected    Y         Y               Y
        public       Y         Y            Y               Y
    (2)这四种权限修饰符在任意时刻只能出现一种。
        public class Demo {}        
    
    5:常见的修饰符(理解)
    (1)分类:
        权限修饰符:private,默认,protected,public
        状态修饰符:static,final
        抽象修饰符:abstract
    (2)常见的类及其组成的修饰
        类:
            默认,public,final,abstract
    
            常用的:public
    
        成员变量:
            private,默认,protected,public,static,final
    
            常用的:private
    
        构造方法:
            private,默认,protected,public
    
            常用的:public
    
        成员方法:
            private,默认,protected,public,static,final,abstract
    
            常用的:public
    (3)另外比较常见的:
        public static final int X = 10;
        public static void show() {}
        public final void show() {}
        public abstract void show();
    
    6:内部类(理解)
    (1)把类定义在另一个类的内部,该类就被称为内部类。
        举例:把类B定义在类A中,类B就被称为内部类。
    (2)内部类的访问规则
        A:可以直接访问外部类的成员,包括私有
        B:外部类要想访问内部类成员,必须创建对象
    (3)内部类的分类
        A:成员内部类
        B:局部内部类
    (4)成员内部类
        A:private 为了数据的安全性
        B:static 为了访问的方便性
    
        成员内部类不是静态的:
            外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
        成员内部类是静态的:
            外部类名.内部类名 对象名 = new 外部类名.内部类名();
    (5)成员内部类的面试题(填空)
        30,20,10
    
        class Outer {
            public int num = 10;
    
            class Inner {
                public int num = 20;
    
                public viod show() {
                    int num  = 30;
    
                    System.out.println(num);
                    System.out.println(this.num);
                    System.out.println(Outer.this.num);
                }
            }
        }
    (6)局部内部类
        A:局部内部类访问局部变量必须加final修饰。
        B:为什么呢?
            因为局部变量使用完毕就消失,而堆内存的数据并不会立即消失。
            所以,堆内存还是用该变量,而改变量已经没有了。
            为了让该值还存在,就加final修饰。
            通过反编译工具我们看到了,加入final后,堆内存直接存储的是值,而不是变量名。
    (7)匿名内部类(掌握)
        A:是局部内部类的简化形式
        B:前提
            存在一个类或者接口
        C:格式:
            new 类名或者接口名() {
                重写方法;
            }
        D:本质:
            其实是继承该类或者实现接口的子类匿名对象
    

    版权声明:本文为小平果原创文章,转载请注明:http://blog.csdn.net/i10630226

  • 相关阅读:
    Python获取秒级时间戳与毫秒级时间戳
    时间戳与时间类型转化(秒级时间戳)
    linux压缩和解压缩命令
    对于Python中@property的理解和使用
    探索性测试方法
    Linux 中 grep 命令的 12 个实践例子
    在 Linux 启动或重启时执行命令与脚本
    亲测的orabbix监控Oracle过程
    find 使用搜集
    Centos7.3-mysql5.7复制安装过程
  • 原文地址:https://www.cnblogs.com/dingxiaoyue/p/4948234.html
Copyright © 2011-2022 走看看