ClassLoader那事儿
ClassLoader是什么
ClassLoader中文类加载器，java编写出来的是.java文件，然后编译成.class文件，而ClassLoader就是把class文件加载到jvm内存中；但jvm启动时，通过不同的类加载器，动态的加载class文件；java比较重要的三类加载器Bootstrap ClassLoader、 Extention ClassLoader、Appclass Loader。
Java中的类加载器
Bootstrap ClassLoader、 Extention ClassLoader、Appclass Loader这三个类加载器分别负责加载不同路径下的文件
Bootstrap CLassloder
它是最顶级的类加载，主要加载载核心类库，其路径为%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等，而这个路径是可以通过jvm启动参数-Xbootclasspath来设置
Extention ClassLoader
扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。
AppClassLoader
当前应用的classpath的所有类
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package sun.misc; import java.io.File; import java.io.IOException; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; import java.net.URLStreamHandler; import java.net.URLStreamHandlerFactory; import java.security.AccessControlContext; import java.security.AccessController; import java.security.CodeSource; import java.security.PermissionCollection; import java.security.PrivilegedAction; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.security.ProtectionDomain; import java.security.cert.Certificate; import java.util.HashSet; import java.util.StringTokenizer; import java.util.Vector; import sun.net.www.ParseUtil; public class Launcher { private static URLStreamHandlerFactory factory = new Launcher.Factory(); private static Launcher launcher = new Launcher();
private static String bootClassPath = System.getProperty("sun.boot.class.path");
private ClassLoader loader; private static URLStreamHandler fileHandler; public static Launcher getLauncher() { return launcher; } public Launcher() { Launcher.ExtClassLoader var1; try { var1 = Launcher.ExtClassLoader.getExtClassLoader(); } catch (IOException var10) { throw new InternalError("Could not create extension class loader"); } try { this.loader = Launcher.AppClassLoader.getAppClassLoader(var1); } catch (IOException var9) { throw new InternalError("Could not create application class loader"); } Thread.currentThread().setContextClassLoader(this.loader); String var2 = System.getProperty("java.security.manager"); if (var2 != null) { SecurityManager var3 = null; if (!"".equals(var2) && !"default".equals(var2)) { try { var3 = (SecurityManager)this.loader.loadClass(var2).newInstance(); } catch (IllegalAccessException var5) { ; } catch (InstantiationException var6) { ; } catch (ClassNotFoundException var7) { ; } catch (ClassCastException var8) { ; } } else { var3 = new SecurityManager(); } if (var3 == null) { throw new InternalError("Could not create SecurityManager: " + var2); } System.setSecurityManager(var3); } } public ClassLoader getClassLoader() { return this.loader; } public static URLClassPath getBootstrapClassPath() { return Launcher.BootClassPathHolder.bcp; }
……………………………… }
从以上源码可以看到
1. 没有看到 Bootstrap ClassLoader，只有bootClassPath，这个应该就是顶级类加载器的加载路径；
2.Launcher 先初始化了Extention ClassLoader ，然后把传入它实例再初始化AppClassLoader。
static class ExtClassLoader extends URLClassLoader { public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
//获取加载的文件，进入getExtDirs可以看到加载的文件路径String var0 = System.getProperty("java.ext.dirs")
final File[] var0 = getExtDirs(); try { return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() { public Launcher.ExtClassLoader run() throws IOException { int var1 = var0.length; for(int var2 = 0; var2 < var1; ++var2) { MetaIndex.registerDirectory(var0[var2]); } //创建类加载 return new Launcher.ExtClassLoader(var0); } }); } catch (PrivilegedActionException var2) { throw (IOException)var2.getException(); } } void addExtURL(URL var1) { super.addURL(var1); } public ExtClassLoader(File[] var1) throws IOException {
//调用父类方法创建，留意到第二个参数为null,这个参数是父加载器，预测ExtClassLoader是没有父加载器的
super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
} private static File[] getExtDirs() { String var0 = System.getProperty("java.ext.dirs"); File[] var1; if (var0 != null) { StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator); int var3 = var2.countTokens(); var1 = new File[var3]; for(int var4 = 0; var4 < var3; ++var4) { var1[var4] = new File(var2.nextToken()); } } else { var1 = new File[0]; } return var1; } private static URL[] getExtURLs(File[] var0) throws IOException { Vector var1 = new Vector(); for(int var2 = 0; var2 < var0.length; ++var2) { String[] var3 = var0[var2].list(); if (var3 != null) { for(int var4 = 0; var4 < var3.length; ++var4) { if (!var3[var4].equals("meta-index")) { File var5 = new File(var0[var2], var3[var4]); var1.add(Launcher.getFileURL(var5)); } } } } URL[] var6 = new URL[var1.size()]; var1.copyInto(var6); return var6; } public String findLibrary(String var1) { var1 = System.mapLibraryName(var1); URL[] var2 = super.getURLs(); File var3 = null; for(int var4 = 0; var4 < var2.length; ++var4) { File var5 = (new File(var2[var4].getPath())).getParentFile(); if (var5 != null && !var5.equals(var3)) { String var6 = VM.getSavedProperty("os.arch"); File var7; if (var6 != null) { var7 = new File(new File(var5, var6), var1); if (var7.exists()) { return var7.getAbsolutePath(); } } var7 = new File(var5, var1); if (var7.exists()) { return var7.getAbsolutePath(); } } var3 = var5; } return null; } private static AccessControlContext getContext(File[] var0) throws IOException { PathPermissions var1 = new PathPermissions(var0); ProtectionDomain var2 = new ProtectionDomain(new CodeSource(var1.getCodeBase(), (Certificate[])null), var1); AccessControlContext var3 = new AccessControlContext(new ProtectionDomain[]{var2}); return var3; } static { ClassLoader.registerAsParallelCapable(); } }
看看ExtenTionClassLoader初始化做了什么
从上面可以看到ExtClassLoader extends URLClassLoader，初始化ExtClassLoader先读取java.ext.dirs路径(D:\java7\jre\lib\ext;C:\Windows\Sun\Java\lib\ext)下的文件，然后调用URLClassLoader.supper()-->
SecureClassLoader.supper()-->ClassLoader.supper()-->方法创建,因为传入的parent是null,可以看到ExtClassLoader 没有父加载器的；简单说就是加载java.ext.dirs的文件创建了个无父加载器的类加载器。
public static void main(String[] args) { System.out.println(System.getProperty("java.ext.dirs")); } /* D:\java7\jre\lib\ext;C:\Windows\Sun\Java\lib\ext */
/*
URLClassLoader extends SecureClassLoader implements Closeable
*/
public URLClassLoader(URL[] urls, ClassLoader parent,
URLStreamHandlerFactory factory) {
super(parent);
// this is to make the stack depth consistent with 1.1
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
ucp = new URLClassPath(urls, factory);
acc = AccessController.getContext();
}
/******************************************************************************/
/*
SecureClassLoader extends ClassLoader
*/
protected SecureClassLoader(ClassLoader parent) {
super(parent);
// this is to make the stack depth consistent with 1.1
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
initialized = true;
}
/******************************************************************************/
/*
ClassLoader类
*/
protected ClassLoader(ClassLoader parent) {
this(checkCreateClassLoader(), parent);
}
private ClassLoader(Void unused, ClassLoader parent) {
this.parent = parent;
if (ParallelLoaders.isRegistered(this.getClass())) {
parallelLockMap = new ConcurrentHashMap<>();
package2certs = new ConcurrentHashMap<>();
domains =
Collections.synchronizedSet(new HashSet<ProtectionDomain>());
assertionLock = new Object();
} else {
// no finer-grained lock; lock on the classloader instance
parallelLockMap = null;
package2certs = new Hashtable<>();
domains = new HashSet<>();
assertionLock = this;
}
}
看看APPClassLoader初始化做了什么
static class AppClassLoader extends URLClassLoader { public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException { final String var1 = System.getProperty("java.class.path"); final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1); return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() { public Launcher.AppClassLoader run() { URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2); return new Launcher.AppClassLoader(var1x, var0); } }); } AppClassLoader(URL[] var1, ClassLoader var2) { super(var1, var2, Launcher.factory); } public Class loadClass(String var1, boolean var2) throws ClassNotFoundException { int var3 = var1.lastIndexOf(46); if (var3 != -1) { SecurityManager var4 = System.getSecurityManager(); if (var4 != null) { var4.checkPackageAccess(var1.substring(0, var3)); } } return super.loadClass(var1, var2); } protected PermissionCollection getPermissions(CodeSource var1) { PermissionCollection var2 = super.getPermissions(var1); var2.add(new RuntimePermission("exitVM")); return var2; } private void appendToClassPathForInstrumentation(String var1) { assert Thread.holdsLock(this); super.addURL(Launcher.getFileURL(new File(var1))); } private static AccessControlContext getContext(File[] var0) throws MalformedURLException { PathPermissions var1 = new PathPermissions(var0); ProtectionDomain var2 = new ProtectionDomain(new CodeSource(var1.getCodeBase(), (Certificate[])null), var1); AccessControlContext var3 = new AccessControlContext(new ProtectionDomain[]{var2}); return var3; } static { ClassLoader.registerAsParallelCapable(); } }
从上面看APPClassLoader也是继承URLClassLoader，与ExtClassLoader不同的是，
1.读取的路径是java.class.path
2.把ExtClassLoader的实例作为APPClassLoader的父加载器，也就是说APPClassLoader的父类加载器是ExtClassLoader
3.加载顺序Bootstrap ClassLoader 到 ExtClassLoader 到 APPClassLoader
父加载器
首先我们先要明确一点是父加载器并不是父类，我们可以通过下面的代码看到
public class MyClassLoader extends URLClassLoader { public MyClassLoader(URL[] repositories) { super(repositories); } public MyClassLoader(URL[] repositories, ClassLoader parent) { super(repositories, parent); } } public static void main(String[] args) { ClassLoader cl = MyClassLoader.class.getClassLoader(); System.out.println("ClassLoader is:"+cl.toString()); System.out.println("ClassLoader\'s parent is:"+cl.getParent().toString()); // System.out.println("ClassLoader\'s grand father is:"+cl.getParent().getParent().toString()); } ClassLoader is:sun.misc.Launcher$AppClassLoader@31fc6b2 ClassLoader's parent is:sun.misc.Launcher$ExtClassLoader@1b2dd1b8
1.MyClassLoader 继承URLClassLoader，但是可以到店MyClassLoader的父加载器是AppClassLoader
2.AppClassLoader 的父加载器是ExtClassLoader，这个在上面分析初始化的APPClassLoader的时候，就可以看到传入ExtClassLoader的实例作为它的加载器，那么ExtClassLoader的父加载器上面初始时是null，我们可以验证一下
public static void main(String[] args) { ClassLoader cl = MyClassLoader.class.getClassLoader(); // System.out.println("ClassLoader is:"+cl.toString()); // System.out.println("ClassLoader\'s parent is:"+cl.getParent().toString()); System.out.println("ClassLoader\'s grand father is:"+cl.getParent().getParent().toString()); } Exception in thread "main" java.lang.NullPointerException at com.suntek.vdm.gw.util.NotifyHandler.main(NotifyHandler.java:373)
从上面的代码可以看到，我们的上面是对的ExtClassLoader的父加载器的确是null.
3.那么其他的没有指定父加载器的ClassLoader的父加载器是什么呢?从上面的代码我们可以看到MyClassLoader的的是APPClassLoader，那么这是为什么呢？难道没有指定父加载器的ClassLoader的默认是APP
/*
这ClassLoader是没有指定父加载器创建方法
*/
protected ClassLoader() {
this(checkCreateClassLoader(), getSystemClassLoader());
}
//这里我们可以看到getSytemClassLoader()这个方法获取父加载器
private ClassLoader(Void unused, ClassLoader parent) {
this.parent = parent;
if (ParallelLoaders.isRegistered(this.getClass())) {
parallelLockMap = new ConcurrentHashMap<>();
package2certs = new ConcurrentHashMap<>();
domains =
Collections.synchronizedSet(new HashSet<ProtectionDomain>());
assertionLock = new Object();
} else {
// no finer-grained lock; lock on the classloader instance
parallelLockMap = null;
package2certs = new Hashtable<>();
domains = new HashSet<>();
assertionLock = this;
}
}
//看到return的是scl，而scl赋值是initSystemClassLoader()方法
public static ClassLoader getSystemClassLoader() {
initSystemClassLoader();
if (scl == null) {
return null;
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkClassLoaderPermission(scl, Reflection.getCallerClass());
}
return scl;
}
//真相就在这里了，就是Launcher的getClassLoader()，而Luancher初始化的前面有看过了，也可以往下看
private static synchronized void initSystemClassLoader() {
if (!sclSet) {
if (scl != null)
throw new IllegalStateException("recursive invocation");
sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
if (l != null) {
Throwable oops = null;
scl = l.getClassLoader();
try {
scl = AccessController.doPrivileged(
new SystemClassLoaderAction(scl));
} catch (PrivilegedActionException pae) {
oops = pae.getCause();
if (oops instanceof InvocationTargetException) {
oops = oops.getCause();
}
}
if (oops != null) {
if (oops instanceof Error) {
throw (Error) oops;
} else {
// wrap the exception
throw new Error(oops);
}
}
}
sclSet = true;
}
}
//这个是Launcher对的getClassLoader,然后在看看下面的图，明白了，就是APPClassLoader
public ClassLoader getClassLoader() {
return this.loader;
}
一层层往下最终APPClassLoader作为默认的ClassLoader；
也就是没有指定的父加载器的默认为是APPClassLoader；
双亲委托
有了父加载器的概念之后，我们就可以开始双亲委托这个玩意了！这部分，发现个哥们写得不错 https://blog.csdn.net/briblue/article/details/54973413，于是就复制了！
一个类加载器查找class和resource时，是通过“委托模式”进行的，它首先判断这个class是不是已经加载成功，如果没有的话它并不是自己进行查找，而是先通过父加载器，然后递归下去，直到Bootstrap ClassLoader，如果Bootstrap classloader找到了，直接返回，如果没有找到，则一级一级返回，最后到达自身去查找这些对象。这种机制就叫做双亲委托。
整个流程可以如下图所示：
大家可以看到2根箭头，蓝色的代表类加载器向上委托的方向，如果当前的类加载器没有查询到这个class对象已经加载就请求父加载器（不一定是父类）进行操作，然后以此类推。直到Bootstrap ClassLoader。如果Bootstrap ClassLoader也没有加载过此class实例，那么它就会从它指定的路径中去查找，如果查找成功则返回，如果没有查找成功则交给子类加载器，也就是ExtClassLoader,这样类似操作直到终点，也就是我上图中的红色箭头示例。
用序列描述一下：
1. 一个AppClassLoader查找资源时，先看看缓存是否有，缓存有从缓存中获取，否则委托给父加载器。
2. 递归，重复第1部的操作。
3. 如果ExtClassLoader也没有加载过，则由Bootstrap ClassLoader出面，它首先查找缓存，如果没有找到的话，就去找自己的规定的路径下，也就是sun.mic.boot.class下面的路径。找到就返回，没有找到，让子加载器自己去找。
4. Bootstrap ClassLoader如果没有查找成功，则ExtClassLoader自己在java.ext.dirs路径中去查找，查找成功就返回，查找不成功，再向下让子加载器找。
5. ExtClassLoader查找不成功，AppClassLoader就自己查找，在java.class.path路径下查找。找到就返回。如果没有找到就让子类找，如果没有子类会怎么样？抛出各种异常。
上面的序列，详细说明了双亲委托的加载流程。我们可以发现委托是从下向上，然后具体查找过程却是自上至下。
这里要说一下ExtClassLoader 这个是没有父加载器，就通过BootStrapClassLoader这个来查找的，下面这个代码的ClassLoader这个类的方法，
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { // First, check if the class has already been loaded
// 首先到缓存寻找
Class c = findLoadedClass(name); if (c == null) { long t0 = System.nanoTime(); try { if (parent != null) {
//如果父加强是空，往上找 c = parent.loadClass(name, false); } else {
//否则就通过BootStrapClassLoader找，也就应该是ExtClassLoader c = findBootstrapClassOrNull(name); } } catch (ClassNotFoundException e) { // ClassNotFoundException thrown if class not found // from the non-null parent class loader } if (c == null) { // If still not found, then invoke findClass in order // to find the class. long t1 = System.nanoTime(); c = findClass(name); // this is the defining class loader; record the stats sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); sun.misc.PerfCounter.getFindClasses().increment(); } } if (resolve) { resolveClass(c); } return c; } }
自定义类加载器
了解我们可以自己写一个简单的加载类
public class MyClassLoader extends URLClassLoader { public MyClassLoader(URL[] repositories) { super(repositories); } public MyClassLoader(URL[] repositories, ClassLoader parent) { super(repositories, parent); } } public final class MyClassLoaderFactory { public static ClassLoader createClassLoader(File unpacked[], final ClassLoader parent) throws Exception { Set<URL> set = new LinkedHashSet<URL>(); if (unpacked != null) { for (int i = 0; i < unpacked.length; i++) { File file = unpacked[i]; if (!file.exists() || !file.canRead()){ continue; } file = new File(file.getCanonicalPath() + File.separator); URL url = file.toURI().toURL(); set.add(url); } } final URL[] array = set.toArray(new URL[set.size()]); return AccessController.doPrivileged(new PrivilegedAction<MyClassLoader>() { @Override public MyClassLoader run() { if (parent == null){ return new MyClassLoader(array); }else { return new MyClassLoader(array, parent); } } }); } }
private static void startWithClassloader(String path) throws Exception { String classPath= path; File[] packed = new File[] { new File(path) }; ClassLoader catalinaLoader = MyClassLoaderFactory.createClassLoader(null, packed, null);
Thread.currentThread().setContextClassLoader(catalinaLoader); Class<?> startupClass = catalinaLoader.loadClass(MAIN_CLASS); Object startupInstance = startupClass.newInstance(); Method method = startupInstance.getClass().getMethod("start"); method.invoke(startupInstance); }
一步一步来吧，首先自定义一个MyClassLoader类继承了URlClassLoader，再对比一下AppClassLoader 的创建，可以说基本一样；
a.获取路径的File[] 文件；
b.然后就调用了AccessController 的native <T> T doPrivileged(PrivilegedAction<T> action)，而关于这个方法的说法，网友们是这么说的：一个调用者在调用doPrivileged方法时，可被标识为 "特权"。在做访问控制决策时，如果checkPermission方法遇到一个通过doPrivileged调用而被表示为 "特权"的调用者，并且没有上下文自变量，checkPermission方法则将终止检查。如果那个调用者的域具有特定的许可，则不做进一步检查，checkPermission安静地返回，表示那个访问请求是被允许的；如果那个域没有特定的许可，则象通常一样，一个异常被抛出
c.调用福利的supper方法创建
Thread.currentThread().setContextClassLoader(catalinaLoader) 这个句有什么用？？
a.在java的应用中，每个线程都有一个contextClassLoad，而充init（）方法可以看到，默认是父线程的上下文类加载器，当月我们也可以通过Thread.currentThread().setContextClassLoader(catalinaLoader)来设置;
b.这个上下文的加载器的作用简单的说，就是当这个线程加载某些类时，通过这加载器进行加载；
c.网友说法：
每个运行中的线程都有一个成员contextClassLoader，用来在运行时动态地载入其它类
系统默认的contextClassLoader是systemClassLoader，所以一般而言java程序在执行时可以使用JVM自带的类、$JAVA_HOME/jre/lib/ext/中的类和$CLASSPATH/中的类
可以使用Thread.currentThread().setContextClassLoader(...);更改当前线程的contextClassLoader，来改变其载入类的行为
ClassLoader被组织成树形，一般的工作原理是：
1) 线程需要用到某个类，于是contextClassLoader被请求来载入该类
2) contextClassLoader请求它的父ClassLoader来完成该载入请求
3) 如果父ClassLoader无法载入类，则contextClassLoader试图自己来载入
注意：WebApp?ClassLoader的工作原理和上述有少许不同：
它先试图自己载入类（在ContextBase?/WEB-INF/...中载入类），如果无法载入，再请求父ClassLoader完成
public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNatives(); } private char name[]; private int priority; private Thread threadQ; private long eetop; /* Whether or not to single_step this thread. */ private boolean single_step; /* Whether or not the thread is a daemon thread. */ private boolean daemon = false; /* JVM state */ private boolean stillborn = false; /* What will be run. */ private Runnable target; /* The group of this thread */ private ThreadGroup group; /* The context ClassLoader for this thread */ private ClassLoader contextClassLoader;
……………… }
private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) { if (name == null) { throw new NullPointerException("name cannot be null"); } this.name = name.toCharArray(); Thread parent = currentThread(); SecurityManager security = System.getSecurityManager(); if (g == null) { /* Determine if it's an applet or not */ /* If there is a security manager, ask the security manager what to do. */ if (security != null) { g = security.getThreadGroup(); } /* If the security doesn't have a strong opinion of the matter use the parent thread group. */ if (g == null) { g = parent.getThreadGroup(); } } /* checkAccess regardless of whether or not threadgroup is explicitly passed in. */ g.checkAccess(); /* * Do we have the required permissions? */ if (security != null) { if (isCCLOverridden(getClass())) { security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION); } } g.addUnstarted(); this.group = g; this.daemon = parent.isDaemon(); this.priority = parent.getPriority(); if (security == null || isCCLOverridden(parent.getClass())) this.contextClassLoader = parent.getContextClassLoader(); else this.contextClassLoader = parent.contextClassLoader; this.inheritedAccessControlContext = acc != null ? acc : AccessController.getContext(); this.target = target; setPriority(priority); if (parent.inheritableThreadLocals != null) this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); /* Stash the specified stack size in case the VM cares */ this.stackSize = stackSize; /* Set thread ID */ tid = nextThreadID(); }
最后通过反射把程序运行起来
一个题目
/** * a.加载->校验->准备->初始化->使用->卸载（准备和初始化） * b.父类静态->本身静态->父类变量和代码块->父类构造器->本身变量和代码块->本身构造器 * c.静态只会加载一次，静态变量一开始会在准备阶段赋值默认值，如st = null, flag = false; * c.而st = new StaticTest()这步骤被镶嵌到static StaticTest st = new StaticTest(); * d.开始执行new StaticTest()，因为静态变量都已经初始化，因此进入：本身变量和代码块->本身构造器 * e.结束new StaticTest()，进入下一个静态变量初始化System.out.println("2");再下一个static boolean flag = true; * f.执行方法staticFunction(); */ public class StaticTest { public static void main(String[] args) { staticFunction(); } { System.out.println("1"); } static StaticTest st = new StaticTest(); static { System.out.println("2"); } StaticTest() { System.out.println("3"); double temp = 3*0.1; if (temp == a){ System.out.println(a+","+flag); }else { System.out.println(a+","+flag); } } private static void staticFunction(){ if (flag){ System.out.println("4"); }else { System.out.println("5"); } } double a=0.3; static boolean flag = true; }
1
3
0.3,false
2
4
