精华内容
下载资源
问答
  • java冷知识
    千次阅读
    2021-04-10 18:36:35

    如何在内循环结束外循环

    关键字break和continue都是结束循环的作用,但是它只能结束它外面的第一层循环,如果代码里面是一层一层又一层的循环,你想直接结束最外层循环又该怎么做呢?

    此时,就需要outer了。

    看如下代码:

    outer:for (int i = 0; i < 10; i++) {
    		for (int j = 0; j < 10; j++) {
    			if(j==0) {
    				System.out.print(j);
    			}else {
    				break outer;   //break;
    			}
    		}
    	}
    

    如果只用break,那么只跳出了里面的for循环,外层还没结束。

    用break;则输出:0000000000

    用break outer;则输出:0

    • outer:就相当于表示它现在代表的某个循环。
    • 如果想跳出它所代表的循环,那么就break outer;
    • 如果想结束它所代表的此次循环,那么就continue outer;
    更多相关内容
  • java冷知识

    2022-03-12 09:18:24
    import java.text.MessageFormat; public class Car { private String name; private String brand; public Car(String name, String brand) { this.brand = brand; this.name = name; }

    各位,请听题,请阅读下面的代码:

    package com.info.csdndemo;
    
    import java.text.MessageFormat;
    
    public class Car {
    
        private String name;
    
        private String brand;
    
        public Car(String name, String brand) {
            this.brand = brand;
            this.name = name;
        }
    
        private void run(Car this, Integer price) {
            String msg = MessageFormat.format("价值 {0} 元的 {1} 品牌的 {1} 正在高速路上奔跑...", price, brand, name);
            System.out.println(msg);
        }
    
        public static void main(String[] args) {
            Car car = new Car("X5", "宝马");
            Integer price = 500000;
            car.run(price);
        }
    }
    
    

    请问上面的代码可以正常编译、运行吗?为什么?

    展开全文
  • ✗ javac StringTest.java StringTest.java:11: 错误: 常量字符串过长
  • 写在前面 JAVA冷知识,今天和小伙伴分享的是 通过内部类的方式实现JAVA的多继承 一个Demo和JDK源码中的具体场景 部分内容参考 《编写高质量代码(改善Java程序的151个建议)》 《Effective Java》中文版第3版 博文理解...

    写在前面


    • JAVA冷知识,今天和小伙伴分享的是
    • 通过内部类的方式实现JAVA的多继承
    • 一个DemoJDK源码中的具体场景
    • 部分内容参考
      • 《编写高质量代码(改善Java程序的151个建议)》
      • 《Effective Java》中文版第3版
    • 博文理解有误的地方小伙伴留言私信一起讨论

    与亲近之人不要说气话,不要说反话,不要不说话。——烽火戏诸侯 《剑来》


    众多周知,对于面向对象语言来讲,JAVA是不支持多继承的,只支持单继承,但是提供了接口来补偿。

    在实际的项目中,接口更多的用于行为的委托,把类本身一些是共性但又是特定的行为委托给一个接口的具体实现,当然接口也可以用于属性的委托,对象结构型的设计模式大都采用接口的方式来实现对对象内部组成的注册和操作

    如果实现java的多继承,其实很简单,关键是对于内部类的特征的掌握,内部类可以继承一个与外部类无关的类,保证了内部类天然独立性,根据这个特性从而实现一个类可以继承多个类的效果

    下面我们看一个Demo,声明父母两个接口,实现父母两个类,看如何通过内部类来继承父母类,而不是通过,接口委托的方式,

    一个Demo

    父亲接口

    package com.liruilong;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description: 父亲接口
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/12  2:48
     */
    public interface Father {
        /**
         * @return: int
         * @Description 强壮的行为
         * @author LiRuilong
         * @date  2022/2/12  2:49
         **/
         int strong();
    }
    

    父亲实现类

    package com.liruilong;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description: 父亲类
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/12  2:51
     */
    public class FatherImpl implements Father {
    
        static  public   String height = "身体超高";
    
       /**
        * @return: int
        * @Description  强壮值
        * @author LiRuilong
        * @date  2022/2/12  2:51
        **/
        @Override
        public int strong() {
            return 8;
        }
    }
    

    母亲接口

    package com.liruilong;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description: 母亲接口
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/12  2:50
     */
    public interface Mother {
       /**
        * @return: int
        * @Description 温柔的行为
        * @author LiRuilong
        * @date  2022/2/12  2:50
        **/
       int Kind();
    }
    

    母亲实现类

    package com.liruilong;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description: 母亲类
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/12  2:51
     */
    public class MotherImpl implements Mother{
        static   public  String pretty = "脸蛋特别漂亮";
       /**
        * @return: int
        * @Description 温柔值
        * @author LiRuilong
        * @date  2022/2/12  2:51
        **/
        @Override
        public int Kind() {
            return 8;
        }
    }
    
    

    OK,准备工作做好了, 看我们如何实现。

    package com.liruilong;
    
    import java.util.logging.Logger;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description: 孩子类
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/12  13:16
     */
    public class Son extends FatherImpl implements Mother {
        static Logger logger = Logger.getAnonymousLogger();
    
        MotherSpecial motherSpecial = new MotherSpecial();
    
    
        @Override
        public int strong() {
            return super.strong() + 1;
        }
    
        @Override
        public int Kind() {
            return motherSpecial.Kind();
        }
    
    
        @Override
        public String toString() {
            return "Son{" +
                    "height=" + height +"," +
                    "pretty=" + MotherSpecial.pretty +
                    '}';
        }
    
    
        public class MotherSpecial extends MotherImpl {
            @Override
            public int Kind() {
                return super.Kind() - 1;
            }
        }
    
        public static void main(String[] args) {
            Son son = new Son();
            logger.info(son.toString());
            logger.info(son.strong()+"");
            logger.info(son.Kind()+"");
        }
    
    }
    

    我们用内部类继承一个外部类无关的类,实现了Son类的多继承

    Bad level value for property: .level
    Bad level value for property: java.util.logging.ConsoleHandler.level
    Can''t set level for java.util.logging.ConsoleHandler
    二月 12, 2022 2:02:06 下午 com.liruilong.Son main
    信息: Son{height=身体超高,pretty=脸蛋特别漂亮}
    二月 12, 2022 2:02:06 下午 com.liruilong.Son main
    信息: 9
    二月 12, 2022 2:02:06 下午 com.liruilong.Son main
    信息: 7
    
    Process finished with exit code 0
    
    

    这里只是讨论这样的写法,我个人认为,这种方法有些鸡肋。这种方式实现的多继承,完全可以通组合的方式来实现,我们简单分析一下优缺点

    优缺点分析

    优点:

    通过内部类的方式,把继承关系控制在类的内部,理论上比通过组合的方式更加安全,代码可读性要好一点。

    更符合设计原则中的迪米特法则,又称最少知道原则(Demeter Principle),一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。

    缺点:

    首先通过继承的方式实现,打破了类的封装性,子类依赖于其超类中特定功能的实现细节。 超类的实现有可能会随着发行版本的不同而有所变化,如果真的发生了变化,即使子类的代码完全没有改变,但是子类可能会遭到破坏因而,子类必须要跟着其超类的更新而演变,除非超类是专门为了扩展而设计的,并且具有很好的文挡说明

    其次,通过这样的方式实现的,不符合常态思想,尤其内部类同名的情况,容易被忽略某些特性(见JDK源码)。而且不满足合成复用原则(Composite Reuse Principle),尽量使用合成/聚合的方式,而不是使用继承。

    JDK源码中的运用

    关于通过内部类来实现java多继承JDK场景,我们简单分析一下

    asList

    List<Integer> integers = Arrays.asList(1, 2, 3);
    

    这个代码小伙伴们一定不陌生,这里通过Arrays工具类来生成一个List,但是这里的List并不是真正的ArrayList,而是在Arrays工具类内部定义的一个继承了AbstractList的静态内部类ArrayList,这里java通过内部类的方式巧妙的实现了。

      .......
        @SafeVarargs
        @SuppressWarnings("varargs")
        public static <T> List<T> asList(T... a) {
            return new ArrayList<>(a);
        }
    
        /**
         * @serial include
         */
        private static class ArrayList<E> extends AbstractList<E>
            implements RandomAccess, java.io.Serializable
        {
            private static final long serialVersionUID = -2764017481108945198L;
            private final E[] a;
    
            ArrayList(E[] array) {
                a = Objects.requireNonNull(array);
            }
        .................    
    

    但是这里同样需要注意的是通过内部类实现多继承要考虑其类的特殊性

    这样生成的List调用add方法会抛不支持的操作的异常,基于ArraysArrayList是一个静态私有内部类,除了Arrays能访问以外,其他类都不能访问,正常的ArrayList中add方法是ArrayList父类提供,Arrays的内部类ArrayList没有覆写add方法。

    下面源码为ArrayList静态内部类实现的个方法。

        /**
         * @serial include
         */
        private static class ArrayList<E> extends AbstractList<E>
            implements RandomAccess, java.io.Serializable
        {
            private static final long serialVersionUID = -2764017481108945198L;
            private final E[] a;
    
            ArrayList(E[] array) {
                a = Objects.requireNonNull(array);
            }
    
            @Override
            public int size() {
                return a.length;
            }
    
            @Override
            public Object[] toArray() {
                return a.clone();
            }
    
            @Override
            @SuppressWarnings("unchecked")
            public <T> T[] toArray(T[] a) {
                int size = size();
                if (a.length < size)
                    return Arrays.copyOf(this.a, size,
                                         (Class<? extends T[]>) a.getClass());
                System.arraycopy(this.a, 0, a, 0, size);
                if (a.length > size)
                    a[size] = null;
                return a;
            }
    
            @Override
            public E get(int index) {
                return a[index];
            }
    
            @Override
            public E set(int index, E element) {
                E oldValue = a[index];
                a[index] = element;
                return oldValue;
            }
    
            @Override
            public int indexOf(Object o) {
                E[] a = this.a;
                if (o == null) {
                    for (int i = 0; i < a.length; i++)
                        if (a[i] == null)
                            return i;
                } else {
                    for (int i = 0; i < a.length; i++)
                        if (o.equals(a[i]))
                            return i;
                }
                return -1;
            }
    
            @Override
            public boolean contains(Object o) {
                return indexOf(o) != -1;
            }
    
            @Override
            public Spliterator<E> spliterator() {
                return Spliterators.spliterator(a, Spliterator.ORDERED);
            }
    
            @Override
            public void forEach(Consumer<? super E> action) {
                Objects.requireNonNull(action);
                for (E e : a) {
                    action.accept(e);
                }
            }
    
            @Override
            public void replaceAll(UnaryOperator<E> operator) {
                Objects.requireNonNull(operator);
                E[] a = this.a;
                for (int i = 0; i < a.length; i++) {
                    a[i] = operator.apply(a[i]);
                }
            }
    
            @Override
            public void sort(Comparator<? super E> c) {
                Arrays.sort(a, c);
            }
        }
    

    即没有实现addremove方法,所以asList返回的为一个长度不可变的列表,数组为多长转换为列表为多长,即不在保持列表动态变长的特性

    subList

    嗯,不多讲,直接上代码

            ArrayList arrayList = new ArrayList();
            LinkedList linkedList = new LinkedList();
            Vector vector = new Vector();
            linkedList.subList(2,3);
            arrayList.subList(2,3);
            vector.subList(2,3);
    

    List提供一个subList方法,与StringsubString有点类似,这里的List通过subList生成子list方式也是通过内部类继承方式的多继承实现的。

    当然这里,具体需要分析,ArrayList其他List的实现的方式略有不同

    ArrayList是自己定义的内部类SubList继承AbstractList实现的

    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
      .......
        public List<E> subList(int fromIndex, int toIndex) {
            subListRangeCheck(fromIndex, toIndex, size);
            return new SubList(this, 0, fromIndex, toIndex);
        }
    .....
        private class SubList extends AbstractList<E> implements RandomAccess {
            private final AbstractList<E> parent;
            private final int parentOffset;
            private final int offset;
            int size;
        .........    
    

    LinkedListsubList方法是由AbstractList实现的,它会根据是不是随机存储提供不同的实现方法subList返回的类也是AbstractList的子类SubList

    public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
      ........
       public List<E> subList(int fromIndex, int toIndex) {
            return (this instanceof RandomAccess ?
                    new RandomAccessSubList<>(this, fromIndex, toIndex) :
                    new SubList<>(this, fromIndex, toIndex));
        }
       class SubList<E> extends AbstractList<E> {
         ...
        }
       class RandomAccessSubList<E> extends SubList<E> implements RandomAccess{
        .......
        }
        ........ 
    }
    

    这里需要注意的是,不管是ArrayList还是LinkedList等其他List,通过SubList内部类生成的List,其所有的方法(get,add,set,remove等)都是在原始列表上操作的,它自身并没有生成一个数组或是链表,也就是子列表只是原列表的一个视图(View),所有的修改都反映在原列表上。

    展开全文
  • 写在前面 今天和小伙伴分享一些java知识点,主要围绕下面几点: 既然数组是一个类, 那么编译后类名是什么?类路径呢? 为什么说动态加载不适合数组? 那应该如何动态加载一个数组? 部分内容参考 《编写高质量代码...

    写在前面


    • 今天和小伙伴分享一些java小知识点,主要围绕下面几点:
    • 既然数组是一个类,
    • 那么编译后类名是什么?类路径呢?
    • 为什么说动态加载不适合数组
    • 那应该如何动态加载一个数组?
    • 部分内容参考
      • 《编写高质量代码(改善Java程序的151个建议)》
      • 《深入理解Java虚拟机》

    君子不妄动,动必有道。君子不徒语,语必有理。君子不苟求,求必有义。君子不虚行,行必有正 ——烽火戏诸侯《剑来》


    一、既然数组是一个类,那么编译后类名是什么?

    通下面的代码我们可以看出,对于基本类型数组,编译后为[+基本类型标识,对于引用类型为[L+引用类类路径

    package com.liruilong;
    
    import java.util.logging.Logger;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description:
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/9  3:08
     */
    public class ArrayDemo {
        static Logger logger = Logger.getAnonymousLogger();
    
        public static void main(String[] args) {
            logger.info("基本类型数组编译后类名:" + int[].class.getName());
            logger.info("引用类型数组编译后类名:" + String[].class.getName());
    
        }
    
    }
    
    二月 09, 2022 3:57:03 上午 com.liruilong.ArrayDemo main
    信息: 基本类型数组编译后类名:[I
    二月 09, 2022 3:57:03 上午 com.liruilong.ArrayDemo main
    信息: 引用类型数组编译后类名:[Ljava.lang.String;
    
    Process finished with exit code 0
    

    java中数组是一个较为特殊的类,不管是基本类型数组,还是引用类型数组,都没有可追溯的类路径

    数组元素类型及编译后的类型

    元素类型编译后的类型
    byte[][B
    char[][C
    Double[][D
    Float[][F
    Int[][I
    Long[][J
    Short[][S
    Boolean[Z
    引用类型(如String)[L引用类型

    二、为什么动态加载不适合数组

    动态加载

    关于动态加载,这里不多讲,相信小伙伴么都不陌生,在原始的JDBC编程连接数据库的时候,通常会通过静态块动态的加载一个连接数据库的驱动类,这里会用到Class.forName(driver),将驱动类加载到内存中。

    当然这里forName只是把一个类加载内存中,并不是产生一个实例对象,也不会执行任何方法,具体的注入的驱动类如何生成对象,如何注册到DriverManager,一般可以通过静态块的方式实现,即类加载的同时生成实例对象并注册

    我们知道在类加载(加载,验证,准备,解析,初始化)的最后一步类初始化的时候,执行类构造器<clinit>()方法,<clinit>()方法编译器自动收集类中的所有类变量的赋值动作的和静态语句块的中的语句合并产生的。编译器收集的顺序是由语句中源文件中出现的顺序决定。

    下面是mysql驱动类的源码

    //
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.mysql.jdbc;
    
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    public class Driver extends NonRegisteringDriver implements java.sql.Driver {
        public Driver() throws SQLException {
        }
    
        static {
            try {
                DriverManager.registerDriver(new Driver());
            } catch (SQLException var1) {
                throw new RuntimeException("Can't register driver!");
            }
        }
    }
    

    为什么不适合数组

    关于动态加载,小伙伴可以看看《深入理解Java虚拟机》,回到我们的问题,为什么数组不适合动态加载,由上面的代码可以知道,当使用forName加载一个类时,需要一个类的全路径,或者说全限定名

    但是不管是基本类型数组,还是引用类型数组,都没有可追溯的类路径,不是一个具体的类,所以在加载的时候,会报错java.lang.ClassNotFoundException

    package com.liruilong;
    
    
    import java.util.logging.Logger;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description:
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/9  3:08
     */
    public class ArrayDemo {
        static Logger logger = Logger.getAnonymousLogger();
    
        public static void main(String[] args) throws ClassNotFoundException {
            Class.forName("java.lang.String[]");
            Class.forName("int[]");
        }
    
    }
    
    
    Exception in thread "main" java.lang.ClassNotFoundException: java/lang/String[]
    	at java.lang.Class.forName0(Native Method)
    	at java.lang.Class.forName(Class.java:264)
    	at com.liruilong.ArrayDemo.main(ArrayDemo.java:19)
    
    Process finished with exit code 1
    

    直接加载不可以,那么加载一个数组编译后的类型是否可行呢?我们来看看

    package com.liruilong;
    
    
    import java.util.logging.Logger;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description:
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/9  3:08
     */
    public class ArrayDemo {
        static Logger logger = Logger.getAnonymousLogger();
    
        public static void main(String[] args) throws ClassNotFoundException {
            Class.forName("[Ljava.lang.String;");
            Class.forName("[I");
        }
    
    }
    
    
    Bad level value for property: .level
    Bad level value for property: java.util.logging.ConsoleHandler.level
    
    Process finished with exit code 0
    

    通过上面我们可以知道,可以加载编译后的类路径动态加载一个对象数组,但是没有意义。并不能通过newInstance()方法生成一个实例对象,在java中数组是定长的,没有长度的数组是不允许存在的。

    package com.liruilong;
    
    
    import java.util.logging.Logger;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description:
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/9  3:08
     */
    public class ArrayDemo {
        static Logger logger = Logger.getAnonymousLogger();
    
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            Class<String[]> aClass = (Class<String[]>) Class.forName("[Ljava.lang.String;");
            String[] strings = aClass.newInstance();
        }
    
    }
    
    
    Bad level value for property: .level
    Bad level value for property: java.util.logging.ConsoleHandler.level
    Exception in thread "main" java.lang.InstantiationException: [Ljava.lang.String;
    	at java.lang.Class.newInstance(Class.java:427)
    	at com.liruilong.ArrayDemo.main(ArrayDemo.java:20)
    Caused by: java.lang.NoSuchMethodException: [Ljava.lang.String;.<init>()
    	at java.lang.Class.getConstructor0(Class.java:3082)
    	at java.lang.Class.newInstance(Class.java:412)
    	... 1 more
    
    Process finished with exit code 1
    

    三、如何动态加载一个数组

    那如何通过类似动态加载的方式生成一个数组,我们可以使用Array数组工具类来动态加载一个数组。

    package com.liruilong;
    
    
    import java.lang.reflect.Array;
    import java.util.logging.Logger;
    
    /**
     * @Project_name: workspack
     * @Package: com.liruilong
     * @Description:
     * @Author: 1224965096@qq.com
     * @WeChat_Official_Accounts: 山河已无恙
     * @blog: https://liruilong.blog.csdn.net/
     * @Date: 2022/2/9  3:08
     */
    public class ArrayDemo {
        static Logger logger = Logger.getAnonymousLogger();
    
        public static void main(String[] args)  {
            String [] strings = (String[]) Array.newInstance(String.class,6);
            logger.info("String数组长度:"+strings.length);
            int[][] ints = (int [][])Array.newInstance(int.class,6,3);
            logger.info("int数组长度:"+ints.length);
        }
    
    }
    
    
    Bad level value for property: .level
    Bad level value for property: java.util.logging.ConsoleHandler.level
    Can't set level for java.util.logging.ConsoleHandler
    二月 09, 2022 5:15:12 上午 com.liruilong.ArrayDemo main
    信息: String数组长度:6
    二月 09, 2022 5:15:12 上午 com.liruilong.ArrayDemo main
    信息: int数组长度:6
    
    Process finished with exit code 0
    

    看看源码,我们会发现这是一个本地方法,通过C或者C++之类的语言实现的

     public static Object newInstance(Class<?> componentType, int length)
            throws NegativeArraySizeException {
            return newArray(componentType, length);
        }
    
    private static native Object newArray(Class<?> componentType, int length)
            throws NegativeArraySizeException;
    

    关于数组的动态加载和小伙伴们分享到这里,生活加油哦 _

    展开全文
  • java进行windows编程 需要调用Windows提供的动态链接库,或者java去调用c++写的dll文件 这里我们要先下载jna和jna-platform这两个第三方jar包 一、创建dll dll.cpp #include "pch.h" #include "dll.h" #include ...
  • 首先我们应该达成一个共识:很多的Java语法糖都是编译器赋予的,而JVM是一个与Java语言解耦的平台。有了这个共识,再来看今天的主角:synthetic修饰符。 我们在阅读JDK反射包源码时,会遇到isSynthetic()方法,其...
  • java项目的大小衡量标准(以代码行作为计量标准的): 微型:只是一个人,甚至是半日工作在几天内完成的软件; 小型:一个人半年内完成的 2000 行以内的程序; 中型: 5 个人在 1 年多的时间内完成的 5000-...
  • public static String getPerson(Integer id, String a, String b) { System.out.println(id); return id.toString(); }
  • JAVA中抽象类(冷知识

    千次阅读 2018-08-29 16:22:01
    所以,java中 抽象类里面可以没有抽象方法。比如HttpServlet类。 抽象类和普通类的区别就在于,抽象类不能被实例化,就是不能被new出来,即使抽象类里面没有抽象方法。 抽象类的作用在于子类对其的继承和实现,也...
  • java冷知识:javac AbstractProcessor

    千次阅读 2019-03-06 22:11:53
    Annotation Processor是javac的一个工具,它用来在编译时扫描和处理注解,通过Annotation Processor可以获取到注解和被注解类的相关信息,然后根据注解自动生成Java代码,省去了手动编写,提高了编码效率。...
  • Java冷知识之——魔数(Magic Number)

    千次阅读 2020-02-26 18:47:21
    在阿里巴巴Java开发手册编程规约第二节常量定义的第一条中写道: 魔法值(即魔数)指的是未经预先定义的常量,而反例中的 “Id#taobao_” 则叫做魔字符串(Magic String)。这一规定在《Clean Code》和各大公司的...
  • 提起Java提供了参数的动态检验,相信很多人对它的理解:仅仅是在执行期检测参数是否合法。常常我们觉得 classloader的加载顺序就应该在执行期。 Java编译器会开启这种静态检测机制,会使用一组类型检测规则来检测...
  • java冷知识之 outer与inner

    千次阅读 2018-06-20 22:31:53
    注意是 有冒号的,这是java的标签,可以换做其他单词,相当于标记一个{} 在c语言中有一个 goto语句,涉及到标记goto可以跳转的位置 比如: int q=0; before:while(q){ System.out.println(q); q++; } //...
  • java冷知识:应用程序安全沙箱

    千次阅读 2019-02-25 18:55:49
    {policypath}需要提供具体路径,默认的策略文件路径是 JAVA_HOME/jre/lib/security/java.policy,它的内容如下 // 内置扩展库授权规则 // 表示 JAVA_HOME/jre/lib/ext/ 目录下的类库可以全权访问任意资源 // ...
  • javac Helloword.java java Hellowword 然后就能打印 但如果: 测试要用到其他jar包: 编译成字节码文件: javac cp 1.jar:2.jar Hellowword.java 执行字节码文件: java cp .:1.jar:2.jar Helloword 才能执行通过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,971
精华内容 7,988
关键字:

java冷知识

友情链接: cable.rar