java基础9

最新推荐文章于 2024-07-23 21:45:09 发布
最新推荐文章于 2024-07-23 21:45:09 发布
阅读量55 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67246843/article/details/124595784
版权

内部类

之前类中可以有变量和方法，今天开始在类中再添加一个元素类。
内部类--包含在类中的类就是内部类
外部类--包含内部类的类就是外部类

1.成员内部类--相当于是java类中的成员变量

基本结构：

public class TestClass {
	
	public  class InnerClass{
		
	}
}

TestClass---外部类
InnerClass---成员内部类
内部类编译后会形成一个新的字节码文件【外部类类名$内部类类型.class】
1.成员内部类可以使用任意的访问限制修饰符。
2.成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
3.成员内部类中的构造方法可以访问其他的构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法    ,this.实例变量/方法,可以省略对象/this】。
4.成员内部类中的实例方法可以访问构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】。
5.成员内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
6.成员内部类中的实例方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
7.外内部类中的构造方法/实例方法可以访问成员内部类的构造方法，实例方法/变量，外部类中的类方法不能访问成员内部类。
8.其他类中是可以访问成员内部类的，需要依赖外部类对象【先创建外部类对象，再依赖外部类对象来创建成员内部类对象】，注意访问限制修饰符。

例如：

//外部类
public class TestClass {
    public String name1="外部类的实例变量";
    public static String address="外部类的静态成员变量";
    public TestClass(){
        System.out.println("外部类的无参构造方法");
        InnerClass icl=new InnerClass();
        System.out.println(icl.name);
        icl.shiLiMethod();

    }
    public TestClass(int num){
        System.out.println("外部类的有参数的构造方法");

        InnerClass icl=new InnerClass();
        System.out.println(icl.name);
        icl.shiLiMethod();
    }
    public void shiLiMethod1(){
        System.out.println("外部类的实例方法");

        InnerClass icl=new InnerClass();
        System.out.println(icl.name);
        icl.shiLiMethod();
    }
    public static void staticMethod(){
        System.out.println("外部类的静态方法");
        //静态方法中不能访问内部类中的元素
        //InnerClass icl=new InnerClass();
        //System.out.println(icl.name);
        //icl.shiLiMethod();
    }
    //成员内部类
    //成员内部类不能写静态元素
    public class InnerClass{
        public String name="内部类的实例变量";
        //public static String address="内部类的静态成员变量";
        public InnerClass(){
            System.out.println("内部类的无参构造方法");
            InnerClass ic=new InnerClass(12);
            System.out.println(ic.name);
            System.out.println(this.name);
            System.out.println(name);
            ic.shiLiMethod();
            this.shiLiMethod();
            shiLiMethod();

            TestClass tc=new TestClass();
            System.out.println(tc.name1);
            System.out.println(TestClass.this.name1);
            System.out.println(name1);
            System.out.println(tc.address);
            System.out.println(TestClass.this.address);
            System.out.println(TestClass.address);
            System.out.println(address);
            tc.shiLiMethod1();
            TestClass.this.shiLiMethod1();
            shiLiMethod1();
            tc.staticMethod();
            TestClass.this.staticMethod();
            TestClass.staticMethod();
            staticMethod();

        }
        public InnerClass(int num){
            System.out.println("内部类的有参数构造方法");
            InnerClass ic1=new InnerClass();
            System.out.println(ic1.name);
            System.out.println(this.name);
            System.out.println(name);
            ic1.shiLiMethod();
            this.shiLiMethod();
            shiLiMethod();


            TestClass tc=new TestClass();
            System.out.println(tc.name1);
            System.out.println(TestClass.this.name1);
            System.out.println(name1);
            System.out.println(tc.address);
            System.out.println(TestClass.this.address);
            System.out.println(TestClass.address);
            System.out.println(address);
            tc.shiLiMethod1();
            TestClass.this.shiLiMethod1();
            shiLiMethod1();
            tc.staticMethod();
            TestClass.this.staticMethod();
            TestClass.staticMethod();
            staticMethod();


        }
        public void shiLiMethod(){
            System.out.println("内部类的实例方法");

            InnerClass ic=new InnerClass(12);
            System.out.println(ic.name);
            System.out.println(this.name);
            System.out.println(name);
            ic.shiLiMethod();
            this.shiLiMethod();
            shiLiMethod();

            TestClass tc=new TestClass();
            System.out.println(tc.name1);
            System.out.println(TestClass.this.name1);
            System.out.println(name1);
            System.out.println(tc.address);
            System.out.println(TestClass.this.address);
            System.out.println(TestClass.address);
            System.out.println(address);
            tc.shiLiMethod1();
            TestClass.this.shiLiMethod1();
            shiLiMethod1();
            tc.staticMethod();
            TestClass.this.staticMethod();
            TestClass.staticMethod();
            staticMethod();
        }
        /*
        public static void staticMethod(){
            System.out.println("内部类的静态方法");
        }

         */
    }
}

其它类中访问成员内部类：

package com.wangxing.chengyuanneibuleidemo;

public class OtherClass {
    public OtherClass(){
        TestClass tc=new TestClass();
        TestClass.InnerClass icl=tc.new InnerClass();
        //TestClass.InnerClass icl=new TestClass().new InnerClass();
        System.out.println(icl.name);
        icl.shiLiMethod();
    }
    public void shiLi(){
        TestClass.InnerClass icl=new TestClass().new InnerClass();
        System.out.println(icl.name);
        icl.shiLiMethod();
    }
    public static void staticMethod(){
        TestClass.InnerClass icl=new TestClass().new InnerClass();
        System.out.println(icl.name);
        icl.shiLiMethod();
    }
}

2.方法内部类--定义在方法中的类，相当于局部变量

基本格式：

package com.wangxing.test2;
public class TestClass {
	public TestClass(){
		 class  InnerClass1{
				
			}
	}
	public  void  testMethod(String canshu){
		 class  InnerClass2{
			
		}
	}
	public static  void  testStaticMethod(String canshu){
		 class  InnerClass3{
			
		}
	}
}

1.方法内部类不能使用任何访问限制修饰符修饰

2.方法内部类中可以有实例变量/方法，构造方法，不能有静态元素

3.方法内部类中的构造方法可以访问本方法内部类中的构造方法，实例方法/变量【对象/this，也可以省略】

4.方法内部类中的实例方法可以访问本方法内部类中的构造方法，实例方法/变量【对象/this，也可以省略】

5.方法内部类中的构造方法/实例方法可以访问本方法的局部变量，默认被访问的局部变量被final修饰【直接变量名称】

6.方法内部类可以访问构造方法，实例方法/变量，静态方法/变量

7.外部类是不能访问到方法内部类的

例如：

package com.wangxing.fangfaneibulei;

import com.sun.org.apache.bcel.internal.classfile.InnerClass;

public class TestClass {
    public String   name="zhangsan";
    public static String   staticname="staticzhangsan";
    public  TestClass(){
//        InnerClass ic1=new InnerClass();

    }
    public  void shiliMethod(){}
    public  static  void  staticfangfa(){}

    public void testMethod(){
        String jubu="局部变量";
        class InnerClass{
            public String a="方法内部类中的实例变量";
            //public static String a1="方法内部类中的静态变量";//方法内部类不能写静态变量
            public InnerClass(){
                System.out.println("方法内部类中的构造方法");
                InnerClass ic=new InnerClass();
                System.out.println(ic.a);
                System.out.println(this.a);
                System.out.println(a);
                ic.shiLi();
                this.shiLi();
                shiLi();
//                jubu=inner;
                System.out.println(jubu);

                TestClass tc=new TestClass();
                System.out.println(tc.name);
                System.out.println(TestClass.this.name);
                System.out.println(name);
                System.out.println(tc.staticname);
                System.out.println(TestClass.this.staticname);
                System.out.println(TestClass.staticname);
                System.out.println(staticname);
                tc.shiliMethod();
                TestClass.this.shiliMethod();
                shiliMethod();
                tc.staticfangfa();
                TestClass.this.staticfangfa();
                TestClass.staticfangfa();
                staticfangfa();
            }
            public void shiLi(){
                System.out.println("方法内部类中的实例方法");
                InnerClass ic=new InnerClass();
                System.out.println(ic.a);
                System.out.println(this.a);
                System.out.println(a);
                ic.shiLi();
                this.shiLi();
                shiLi();

                TestClass tc=new TestClass();
                System.out.println(tc.name);
                System.out.println(TestClass.this.name);
                System.out.println(name);
                System.out.println(tc.staticname);
                System.out.println(TestClass.this.staticname);
                System.out.println(TestClass.staticname);
                System.out.println(staticname);
                tc.shiliMethod();
                TestClass.this.shiliMethod();
                shiliMethod();
                tc.staticfangfa();
                TestClass.this.staticfangfa();
                TestClass.staticfangfa();
                staticfangfa();
            }
//            public static void staticMethod(){}//方法内部类中不能有静态元素
        }
    }
}

3.静态镶嵌类---相当于是Java类中的静态变量

基本格式：

package com.wangxing.test3;
public class TestClass {
	public static class  InnerClass{
		
	}
}

1.静态嵌套类中可以有构造方法，实例方法/变量，静态方法/变量

2.静态嵌套类中的构造方法/实例方法可以访问本静态嵌套中的构造方法，实例方法/变量，静态方法/变量

3.静态嵌套类中的静态方法可以访问本静态嵌套类中的构造方法，实例变量/方法【只能对象访问】，静态变量/方法

4.静态嵌套类中的方法可以访问外部类中的构造方法，实例变量/方法【只能对象访问】，静态变量/方法【对象/类名访问】

5.静态嵌套类中不能有this.

6.外部类中的方法可以访问静态嵌套类中的构造方法，实例方法/变量【只能对象】，静态变量/方法【对象/类名访问】

7.其他类中可以访问静态嵌套类【new 外部类类名.静态嵌套类名()】。注意访问限制修饰符

例如：

package com.wangxing.staticneibulei;

public class TestClass {
    public String name="实例变量";
    public static String address="静态成员变量";
    public TestClass(){
        System.out.println("构造方法");
        //外部类调用静态嵌套类中的实例变量/方法必须使用静态嵌套类的对象，静态方法可以使用对象和类名调用，且不可省略
        InnerClass icl=new InnerClass();
        System.out.println(icl.name1);
//        System.out.println(InnerClass.this.name1);
//        System.out.println(name1);
        System.out.println(icl.address1);
        System.out.println(InnerClass.address1);
//        System.out.println(address1);
        icl.shiLiMethod();
//        InnerClass.this.shiLiMethod();
//        shiLiMethood();
        icl.jingTai();
        InnerClass.jingTai();
//        jingtai();
    }

    public void shiLi(){
        System.out.println("实例方法");

        InnerClass icl=new InnerClass();
        System.out.println(icl.name1);
//        System.out.println(InnerClass.this.name1);
//        System.out.println(name1);
        System.out.println(icl.address1);
        System.out.println(InnerClass.address1);
//        System.out.println(address1);
        icl.shiLiMethod();
//        InnerClass.this.shiLiMethod();
//        shiLiMethood();
        icl.jingTai();
        InnerClass.jingTai();
//        jingtai();
    }
    public static void staticMethod(){
        System.out.println("静态方法");

        InnerClass icl=new InnerClass();
        System.out.println(icl.name1);
//        System.out.println(InnerClass.this.name1);
//        System.out.println(name1);
        System.out.println(icl.address1);
        System.out.println(InnerClass.address1);
//        System.out.println(address1);
        icl.shiLiMethod();
//        InnerClass.this.shiLiMethod();
//        shiLiMethood();
        icl.jingTai();
        InnerClass.jingTai();
//        jingtai();
    }
    public static class InnerClass{
        public String name1="静态嵌套类的实例变量";
        public static String address1="静态嵌套类的静态变量";
        public InnerClass(){
            System.out.println("静态嵌套类的构造方法");

            InnerClass ic=new InnerClass();
            System.out.println(ic.name1);
            System.out.println(this.name1);
            System.out.println(name1);
            System.out.println(ic.address1);
            System.out.println(this.address1);
            System.out.println(InnerClass.address1);
            System.out.println(address1);
            ic.shiLiMethod();
            this.shiLiMethod();
            shiLiMethod();
            ic.jingTai();
            this.jingTai();
            InnerClass.jingTai();
            jingTai();

            TestClass tc=new TestClass();
            System.out.println(tc.name);
//            System.out.println(TestClass.this.name);
//            System.out.println(name);
            System.out.println(tc.address);
            System.out.println(TestClass.address);
            System.out.println(address);
            tc.shiLi();
//            shiLi();
            tc.staticMethod();
            TestClass.staticMethod();
            staticMethod();
        }

        public void shiLiMethod(){
            System.out.println("静态嵌套类的实例方法");

            InnerClass ic=new InnerClass();
            System.out.println(ic.name1);
            System.out.println(this.name1);
            System.out.println(name1);
            System.out.println(ic.address1);
            System.out.println(this.address1);
            System.out.println(InnerClass.address1);
            System.out.println(address1);
            ic.shiLiMethod();
            this.shiLiMethod();
            shiLiMethod();
            ic.jingTai();
            this.jingTai();
            InnerClass.jingTai();
            jingTai();
// 静态嵌套类中的方法调用外部类中的实例变量/方法时必须使用外部类对象进行调用，静态方法可以使用类名，对象进行调用，且可以省略不写
            TestClass tc=new TestClass();
            System.out.println(tc.name);
//            System.out.println(TestClass.this.name);
//            System.out.println(name);
            System.out.println(tc.address);
            System.out.println(TestClass.address);
            System.out.println(address);
            tc.shiLi();
//            shiLi();
            tc.staticMethod();
            TestClass.staticMethod();
            staticMethod();
        }
        public static void jingTai(){
            System.out.println("静态嵌套类的静态方法");
            //静态嵌套类中的静态方法调用实例变量/方法时必须使用对象进行调用，调用静态方法时可以使用对象、类名进行调用，也可以省略，其中this不能出现
            InnerClass ic=new InnerClass();
            System.out.println(ic.name1);
            System.out.println(ic.address1);
            System.out.println(InnerClass.address1);
            System.out.println(address1);
            ic.shiLiMethod();
            ic.jingTai();
            InnerClass.jingTai();
            jingTai();

            TestClass tc=new TestClass();
            System.out.println(tc.name);
//           System.out.println(TestClass.this.name);
//            System.out.println(name);
            System.out.println(tc.address);
            System.out.println(TestClass.address);
            System.out.println(address);
            tc.shiLi();
//            shiLi();
            tc.staticMethod();
            TestClass.staticMethod();
            staticMethod();
        }

        public static void jingTaiMethod(){
            InnerClass ic=new InnerClass();
            System.out.println(ic.name1);
            System.out.println(ic.address1);
            System.out.println(InnerClass.address1);
            System.out.println(address1);
            ic.shiLiMethod();
            ic.jingTai();
            InnerClass.jingTai();
            jingTai();
        }
    }
}

其他类访问静态嵌套类：

package com.wangxing.staticneibulei;

public class OtherClass {
    public OtherClass(){
        //在其他类中调用静态嵌套类，必须使用外部类调用静态嵌套类来创建对象
        TestClass.InnerClass ic=new TestClass.InnerClass();
        //在其他类中调用静态嵌套类中的实例变量/方法必须使用对象调用，调用静态方法使用对象和类名调用，且不可以省略
        System.out.println(ic.name1);
//        System.out.println(TestClass.InnerClass.this.name1);
//        System.out.println(name1);
        System.out.println(ic.address1);
        System.out.println(TestClass.InnerClass.address1);
//        System.out.println(address);
        ic.shiLiMethod();
//        TestClass.InnerClass.this.shiLiMethod();
//        shiLiMethod();
        ic.jingTai();
        TestClass.InnerClass.jingTai();
//        jingTai();
    }
    public void shiLiFangFa(){
        //在其他类中调用静态嵌套类，必须使用外部类调用静态嵌套类来创建对象
        TestClass.InnerClass ic=new TestClass.InnerClass();
        //在其他类中调用静态嵌套类中的实例变量/方法必须使用对象调用，调用静态方法使用对象和类名调用，且不可以省略
        System.out.println(ic.name1);
//        System.out.println(TestClass.InnerClass.this.name1);
//        System.out.println(name1);
        System.out.println(ic.address1);
        System.out.println(TestClass.InnerClass.address1);
//        System.out.println(address);
        ic.shiLiMethod();
//        TestClass.InnerClass.this.shiLiMethod();
//        shiLiMethod();
        ic.jingTai();
        TestClass.InnerClass.jingTai();
//        jingTai();
    }
    public static void staticFangFa(){
        //在其他类中调用静态嵌套类，必须使用外部类调用静态嵌套类来创建对象
        TestClass.InnerClass ic=new TestClass.InnerClass();
        //在其他类中调用静态嵌套类中的实例变量/方法必须使用对象调用，调用静态方法使用对象和类名调用，且不可以省略
        System.out.println(ic.name1);
//        System.out.println(TestClass.InnerClass.this.name1);
//        System.out.println(name1);
        System.out.println(ic.address1);
        System.out.println(TestClass.InnerClass.address1);
//        System.out.println(address);
        ic.shiLiMethod();
//        TestClass.InnerClass.this.shiLiMethod();
//        shiLiMethod();
        ic.jingTai();
        TestClass.InnerClass.jingTai();
//        jingTai();
    }
}

4.匿名内部类---没有名字的java类,在不用创建出新类的情况下，构建出当前类的子类，构建的子类没有名字，所以叫匿名内部类

基本格式：

package com.wangxing.test4;

public class Person {
	public  void  personInfo(){
		System.out.println("Person类的实例方法");
	}
}

package com.wangxing.test4;
public class Main {
	public static void main(String[] args) {
		Person  per=new Person(){
			public  void  personInfo(){
				System.out.println("重写Person类的personInfo方法");
			}
		};
		per.personInfo();
	}
}

new Person(){
	public  void  personInfo(){
			System.out.println("重写Person类的personInfo方法");
	}
}

上面的代码就是一个匿名内部类的格式，就相当于Person类的子类，只是没有名字，所以叫匿名内部类。
继承式的匿名内部类
例如:

package com.wangxing.nimingneibulei;

public class DemoClass {
    public void shiLiMethod(){
        System.out.println("实例方法");
    }
    public void shiLiMethod(TestClass TestClass){
        System.out.println("参数类型为TestClass的实例方法");
    }
    public void shisLiMethod(MyInterface myInterface){
        System.out.println("参数类型为MyInterface的实例方法");
    }
}
package com.wangxing.nimingneibulei;

public abstract class TestClass {
    public abstract void abstractMethod();
}
package com.wangxing.nimingneibulei;

public interface MyInterface {
    void chouXiang();
}
package com.wangxing.nimingneibulei;

public class TestMain {
    public static void main(String[] args) {

        DemoClass dc=new DemoClass(){
            public void shiLiMethod(){
                System.out.println("重写DemoClass的实例方法");
            }
        };
        dc.shiLiMethod();
        /*
        DemoClass dc=new DemoClass();
        dc.shiLiMethod(new TestClass() {
            @Override
            public void abstractMethod() {
                System.out.println("重写抽象类的抽象方法");
            }
        });
        dc.shisLiMethod(new MyInterface() {
            @Override
            public void chouXiang() {
                System.out.println("重写接口的抽象方法");
            }
        });
         */
    }
}

优点:避免创建额外的独立子类
缺点：不易理解，不易阅读

总结：

内部类：

1.成员内部类---成员变量【实例变量】

2.方法内部类---局部变量

3.静态嵌套类---静态成员变量

4.匿名内部类---创建子类

aduhaohaogan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
java基础案例教程
01-08
java基础的案例分析和实例教学,适合新手及回顾查阅,对于夯实基础有好处
java基础知识图
01-18
总结了java基础的架构，从JDK安装到反射的知识
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
weixin_70987470的博客
07-20 331
从本地导入Junit
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 839
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 726
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 697
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
java算法day19
TOMOT77的博客
07-20 265
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
springboot之自动装配
weixin_50153914的博客
07-23 178
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1137
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1193
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 851
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 932
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
[Jenkins]jenkins-cli.jar调用用户token启动任务
最新发布
China_Yanhy的博客
07-23 307
jenkins-cli.jar调用用户token启动任务
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 781
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
javaScrip的学习（一）
weixin_65450681的博客
07-19 1286
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 555
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1044
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Java入门基础.pdf
《Java入门基础.pdf》是一本介绍Java入门基础知识的文件，文件共包括五个章节。在前言部分，介绍了本书的目录和简要说明。接着，在第1章中，详细介绍了Java开发入门的相关概念，包括JDK、JRE、JVM的区别与联系。在第...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值