精华内容
下载资源
问答
  • 1 非静态代码块非静态代码块特点①可以为实例变量(非静态的属性)初始化②每次创建对象时候,都会执行一次,且先于构造器执行③若有多个非静态的代码,那么按照定义顺序从上到下依次执行④代码中既可以调用...

    1 非静态代码块

    非静态代码块特点

    ①可以为实例变量(非静态的属性)初始化

    ②每次创建对象的时候,都会执行一次,且先于构造器执行

    ③若有多个非静态的代码块,那么按照定义的顺序从上到下依次执行

    ④代码块中既可以调用非静态的变量和方法,也可以可以调用静态的变量和方法

    测试代码:

    public class BlockTest {

    public static void main(String[] args) {

    MyClass my1 = new MyClass();

    //MyClass my2 = new MyClass("java");

    }

    }

    class MyClass {

    private String str;

    {

    System.out.println("非静态代码块1");

    }

    public MyClass() {

    System.out.println("无参构造");

    }

    public MyClass(String str) {

    this.str = str;

    System.out.println("有参构造");

    }

    {

    System.out.println("非静态代码块2");

    }

    }

    运行结果:

    非静态代码块1

    非静态代码块2

    无参构造

    2 实例初始化

    实例初始化过程:创建对象时,为对象进行初始化的操作

    ①为成员变量显式赋值

    ②执行非静态代码块

    ③执行构造器

    Java编译器会把这三个部分的代码,合成一个叫做 ([形参列表]) 实例初始化方法

    即编译后的.class字节码信息中,是没有构造器这个概念。

    ([形参列表]) 实例初始化方法的代码就是由三个部分组成:

    ①成员变量显式赋值的代码

    ②非静态代码块中的代码

    ③构造器中的代码

    其中①和②按定义顺序依次执行,③最后执行。

    而且,有几个构造器,就会有几个实例初始化方法。那么当你创建对象的时候,调用对应的构造器时,其实执行的是对应的实例初始化方法 ([形参列表])

    代码示例:

    public class InitTest {

    public static void main(String[] args) {

    Demo d1 = new Demo();

    //Demo d2 = new Demo("java");

    }

    }

    class Demo{

    {

    System.out.println("非静态代码块1");

    }

    private String str = assign();//调用方法,为str进行显式赋值

    public Demo(){

    System.out.println("无参构造");

    }

    public Demo(String str){

    this.str = str;

    System.out.println("有参构造");

    }

    {

    System.out.println("非静态代码块2");

    }

    public String assign(){

    System.out.println("为成员变量赋值");

    return "hello";

    }

    }

    3 子类实例初始化

    (1)先执行父类的实例初始化方法

    它由三部分组成:

    成员变量的显式赋值

    非静态代码块

    构造器

    (2)再执行子类的实例初始化方法

    它由三部分组成:

    成员变量的显式赋值

    非静态代码块

    构造器

    super()或super(实参列表) 表面是调用父类的构造器,其实是调用父类对应的实例初始化方法

    super()或super(实例列表) 表面是在子类构造器的首行,其实是在子类实例初始化方法的首行

    代码示例:

    public class InitTest2 {

    public static void main(String[] args) {

    Son s = new Son();

    }

    }

    class Father {

    private String strFather = assignFather();

    {

    System.out.println("父类的非静态代码块");

    }

    public Father(){

    System.out.println("父类的无参构造");

    }

    public String assignFather(){

    System.out.println("父类的assignFather()");

    return "father";

    }

    }

    class Son extends Father {

    private String strSon = assignSon();

    {

    System.out.println("子类的非静态代码块");

    }

    public Son(){

    //super() ==> 调用父类的实例初始化方法,而且它在子类实例初始化方法的首行

    System.out.println("子类的无参构造");

    }

    public String assignSon(){

    System.out.println("子类的assignSon()");

    return "son";

    }

    }

    运行结果:

    父类的assignFather()

    父类的非静态代码块

    父类的无参构造

    子类的assignSon()

    子类的非静态代码块

    子类的无参构造

    子类为成员变量显式赋值方法重写父类显式赋值方法时,调用的子类重写的方法,代码示例:

    public class InitTest3 {

    public static void main(String[] args) {

    Son s = new Son();

    }

    }

    class Father {

    private String strFu = assign();

    {

    System.out.println("父类的非静态代码块");

    }

    public Father(){

    System.out.println("父类的无参构造");

    }

    public String assign(){

    System.out.println("父类的assign()");

    return "father";

    }

    }

    class Son extends Father {

    private String strSon = assign();

    {

    System.out.println("子类的非静态代码块");

    }

    public Son(){

    //super() ==>调用父类的实例初始化方法,而且它在子类实例初始化方法的首行

    System.out.println("子类的无参构造");

    }

    public String assign(){

    System.out.println("子类的assign()");

    return "son";

    }

    }

    运行结果:

    子类的assign()

    父类的非静态代码块

    父类的无参构造

    子类的assign()

    子类的非静态代码块

    子类的无参构造

    展开全文
  • 非静态代码和实例初始化方法 类成员: (1)属性 (2)方法 (3) 构造器 类第四成员:代码 作用:为属性初始化 一、非静态代码 1、语法格式: 【修饰符】 class 类名 【extends 父类】{ { 非静态的代码...

    非静态代码块和实例初始化方法

    类的成员: (1)属性 (2)方法 (3) 构造器

    类的第四成员:代码块

    作用:为属性初始化

    一、非静态代码块

    1、语法格式
    【修饰符】 class 类名 【extends 父类】{
    {
    非静态的代码块
    }
    }

    2、执行特点
    (1)在创建对象的时候自动执行,每创建一个对象就执行一次
    如果有多个非静态的代码块,按照顺序执行
    (2)先与构造器执行的
    (3)非静态代码块与属性的显示赋值他两谁在上面谁先执行
    (4)如果创建了子类的对象,会先执行父类的非静态代码块、父类的属性的显试赋值、父类的构造器

    3、实例初始化(…)
    (1) .java代码编译为 .class时,会把diamante重新组装,如果类中有n个构造器,就会重新组装为n个实例化初始方法。
    无参构造 -> ()
    有参构造 -> (形参列表)

    (2)实例初始化方法由三个部分组成
    (A)属性的显式赋值语句
    (B)非静态代码块语句
    (C)构造器语句
    其中(A)(B)是按照顺序组装的,但是(C)无论放在那里,都在最后

    (3)创建子类对象的时候会先调用父类的实例化方法

    public class TestNonStaticBlock {
    	public static void main(String[] args) {
    		Son s1 = new Son();
    
    		
    		//构造器是最后执行的所以num的值是3
    		System.out.println(s1.getNum());//3
    		
    	}
    }
    
    class Father{
    	Father(){
    		System.out.println("父类的无参构造");
    	}
    	{
    		System.out.println("父类的非静态的代码块1");
    	}
    	
    	{
    		System.out.println("父类的非静态的代码块2");
    	}
    	
    	private int i= getNumberI();//为i属性赋值的
    	
    	public int getNumberI() {
    		System.out.println("getNumberI()");
    		return 1;
    	}
    
    	public int getI() {
    		return i;
    	}
    
    	
    }
    
    class Son extends Father{
    	
    	Son(){
    		System.out.println("无参构造");
    		num = 3;
    	}
    	{
    		System.out.println("非静态的代码块1");
    		num = 2;
    	}
    	
    	{
    		System.out.println("非静态的代码块2");
    	}
    	
    	private int num= getNumber();//为num属性赋值的
    	
    	public int getNumber() {
    		System.out.println("getNum()");
    		return 1;
    	}
    
    	public int getNum() {
    		return num;
    	}
    	
    	
    }
    
    
    
    

    在这里插入图片描述

    下面程序运行时的内存顺序
    在这里插入图片描述

    非静态代码块和构造器和显式赋值之间的执行顺序(题目很重要,有时间得看一下)

    练习一
    public class TestInit1 {
    	public static void main(String[] args) {
    		A obj = new A(20);
    	}
    }
    class A{
    	private int a = getInt();
    	
    	{
    		a++;
    		System.out.println("(1)A非静态代码块");
    		System.out.println("(1)a = " + a);
    	}
    	
    	A(int num){
    		a = num;
    		System.out.println("(2)A有参构造");
    		System.out.println("(2)a = " + a);
    	}
    	
    	private int getInt(){
    		System.out.println("(3)A->getInt");
    		System.out.println("(3)a = " + a);
    		return 1;
    	}
    }
    
    /*
    (3)A->getInt
    (3)a = 0
    (1)A非静态代码块
    (1)a = 2
    (2)A有参构造
    (2)a = 20
     */
    
    

    在这里插入图片描述

    练习二
    /*
    实例初始化的过程:
    	(1)实例初始化:调用/执行 实例初始化的方法<init>(...)
    	(2)实例初始化方法的方法体由三个部分组成
    	第一 属性显示赋值
    	第二 非静态代码块
    	第三 构造器
    	(3)创建子类对象的时候会先执行父类的实例初始化方法
     */
    
    public class TestInit2 {
    	public static void main(String[] args) {
    		A obj = new B(20);
    	}
    }
    class A{
    	private int a = getInt();
    	
    	{
    		a++;
    		System.out.println("(1)非静态代码块");
    		System.out.println("(1)a = " + a);
    	}
    	
    	A(int num){
    		a = num;
    		System.out.println("(2)A:有参构造");
    		System.out.println("(2)a = " + a);
    	}
    	
    	public int getInt(){
    		System.out.println("(3)A->getInt");
    		System.out.println("(3)a = " + a);
    		return 1;
    	}
    }
    class B extends A{
    	private int b = getIntValue();
    	
    	{
    		b++;
    		System.out.println("(1)B:非静态代码块");
    		System.out.println("(1)b = " + b);
    	}
    	
    	B(int num){
    		super(num);
    		b = num;
    		System.out.println("(2)B:有参构造");
    		System.out.println("(2)b = " + b);
    	}
    	
    	public int getIntValue(){
    		System.out.println("(3)B->getIntValue");
    		System.out.println("(3)b = " + b);
    		return 1;
    	}
    }
    
    /*
    (3)A->getInt
    (3)a = 0
    (1)非静态代码块
    (1)a = 2
    (2)A:有参构造
    (2)a = 20
    (3)B->getIntValue
    (3)b = 0
    (1)B:非静态代码块
    (1)b = 2
    (2)B:有参构造
    (2)b = 20
     */
    

    在这里插入图片描述

    练习三

    (里面有关于多态重写的问题,比较复杂好好看看)
    如果看了不是很懂的话再去看看练习四的注释

    /*
    实例初始化的过程:
    	(1)实例初始化:调用/执行 实例初始化的方法<init>(...)
    	(2)实例初始化方法的方法体由三个部分组成
    	第一 属性显示赋值
    	第二 非静态代码块
    	第三 构造器
    	(3)创建子类对象的时候会先执行父类的实例初始化方法
    	
    	(4) 注意:通常面试题当中注意方法重写的问题
    	
    父类A的实例初始化的方法<init>(...)
    ❤❤(1)a = getInt();  --> 等价于a = this.getInt()  这个this表示当前的对象,表示正在创建的对象,现在正在创建的是子类的对象,那么通过子类的对象调用getInt()是执行子类的重写的getInt()
    (2){
    		a++;
    		System.out.println("(1)非静态代码块");
    		System.out.println("(1)a = " + a);
    	}
    (3)构造器
            a = num;
    		System.out.println("(2)A:有参构造");
    		System.out.println("(2)a = " + a);
    
    子类B的实例初始化的方法<init>(...)
    (1)b = getInt();
    (2){
    		b++;
    		System.out.println("(1)B:非静态代码块");
    		System.out.println("(1)b = " + b);
    	}
    (3)构造器
    		super(num);
    		b = num;
    		System.out.println("(2)B:有参构造");
    		System.out.println("(2)b = " + b);
     */
    public class TestInit3 {
    	public static void main(String[] args) {
    		A obj = new B(20);
    	}
    }
    class A{
    	private int a = getInt();//这个地方有一个陷阱,注意是重写
    	
    	{
    		a++;
    		System.out.println("(1)非静态代码块");
    		System.out.println("(1)a = " + a);
    	}
    	
    	A(int num){
    		a = num;
    		System.out.println("(2)A:有参构造");
    		System.out.println("(2)a = " + a);
    	}
    	
    	public int getInt(){
    		System.out.println("(3)A->getInt");
    		System.out.println("(3)a = " + a);
    		return 1;
    	}
    }
    class B extends A{
    	private int b = getInt();
    	
    	{
    		b++;
    		System.out.println("(1)B:非静态代码块");
    		System.out.println("(1)b = " + b);
    	}
    	
    	B(int num){
    		super(num);
    		b = num;
    		System.out.println("(2)B:有参构造");
    		System.out.println("(2)b = " + b);
    	}
    	
    	public int getInt(){
    		System.out.println("(3)B->getInt");
    		System.out.println("(3)b = " + b);
    		return 1;
    	}	
    }
    
    /*
     (3)A->getInt
     (3)a = 0
     (1)非静态代码块
     (1)a = 2
     (2)A:有参构造
     (2)a = 20
     */
    
    

    在这里插入图片描述

    练习四
    /*
     *Override或者Overwrite  重写  覆盖
     *this在类中,就看的是A类中的getInt(),就近原则,因为这个getInt没有被覆盖掉
     *如果getInt()被重写,被覆盖,即使在A类中,通过子类的对象this,看到的只有子类重写后的getInt()方法 
     * 
     */
    
    public class TestInit4 {
    	public static void main(String[] args) {
    		A obj = new B(20);
    	}
    }
    class A{
    	private int a = getInt();//因为getInt() 方法是private,在子类中不可见不会被重写
    	//虽然这个地方也是this.getInt(),但是子类中是私有的,所以根据就近原则调用的父类的getInt()
    	{
    		a++;
    		System.out.println("(1)非静态代码块");
    		System.out.println("(1)a = " + a);
    	}
    	
    	A(int num){
    		a = num;
    		System.out.println("(2)A:有参构造");
    		System.out.println("(2)a = " + a);
    	}
    	
    	private int getInt(){
    		System.out.println("(3)A->getInt");
    		System.out.println("(3)a = " + a);
    		return 1;
    	}
    }
    class B extends A{
    	private int b = getInt();
    	
    	{
    		b++;
    		System.out.println("(1)B:非静态代码块");
    		System.out.println("(1)b = " + b);
    	}
    	
    	B(int num){
    		super(num);
    		b = num;
    		System.out.println("(2)B:有参构造");
    		System.out.println("(2)b = " + b);
    	}
    	
    	private int getInt(){
    		System.out.println("(3)B->getInt");
    		System.out.println("(3)b = " + b);
    		return 1;
    	}	
    }
    
    

    在这里插入图片描述

    展开全文
  • 执行优先级高于非静态的初始化块,它会在类初始化时候执行一次,执行完成便销毁,它仅能初始化类变量,即static修饰数据成员。2.随着类加载而执行,而且只执行一次先说一下类加载,一个程序要想运行,首先要把...

    关于静态代码块

    静态代码块的写法:

    static{

    System.out.println("我是静态代码块");

    }

    静态代码块的特点:

    1.执行优先级高于非静态的初始化块,它会在类初始化的时候执行一次,执行完成便销毁,它仅能初始化类变量,即static修饰的数据成员。

    2.随着类的加载而执行,而且只执行一次

    先说一下类加载,一个程序要想运行,首先要把代码加载到内存中,然后才能去和CPU交流,这是冯诺依曼计算机规定的。Java也是一样,Java的.class字节码文件要想执行,首先也要加载到内存,由类加载器把字节码文件的代码加载到内存中,这一步就叫类加载,这是首先要进行的。

    关于非静态代码块:

    非静态代码块的写法:

    {

    System.out.println("我是非静态代码块");

    }

    非静态代码块的特点:

    1.执行的时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块,在每个对象生成时都会被执行一次,它可以初始化类的实例变量。非静态初始化块会在构造函数执行时,在构造函数主体代码执行之前被运行。

    2.非静态代码块在每new一次就执行一次

    静态代码块与非静态代码库的异同点:

    相同点:

    都是在JVM加载类时且在构造方法执行之前执行,在类中都可以定义多个,一般在代码块中对一些static变量进行赋值。

    不同点:

    1.静态代码块在非静态代码块之前执行(静态代码块--》非静态代码块--》构造方法)。

    静态代码块只在第一次new执行一次,之后不在执行,而非静态代码块在每new一次就执行一次。非静态代码块可以     在普通方法中定义(个人感觉作用不大);而静态代码块不行。

    2.静态代码块是自动执行的;

    静态方法是被调用的时候才执行的;

    作用:

    静态代码块可以用来初始化一些项目最常用的变量和对象;静态方法可以用作不创建对象也可以能需要执行的代码。

    关于构造函数:

    构造函数写法:

    public class Father{

    Father(){    System.out.println("我是构造函数");

    }

    }

    构造函数的特点:

    1.构造函数的名字必须和类名完全相同,构造函数不能有

    2.返回值,不写void,构造函数不可以被子类继承

    3.构造函数可以重载但是不可以被子类覆盖。

    关于静态代码块,非静态代码块及构造函数的执行顺序

    1.只在父类Class中测试

    public classFather {static{

    System.out.println("父类的静态代码块");

    }

    {

    System.out.println("父类的非静态代码块");

    }

    Father() {

    System.out.println("父类的构造函数");

    }public static voidmain(String[] args) {

    System.out.println("new父类前的main方法");newFather();

    System.out.println("new父类后的main方法");

    }

    }

    8564072bbfba6fc115eebb97a5bd8f91.png

    总结:

    只在父类Class中的执行顺序:

    静态代码块>new 对象前的main方法顺序执行>非静态代码块>构造函数>new 对象后的main方法顺序执行

    2.在继承了父类的子类Class中测试

    public class Son extendsFather {static{

    System.out.println("子类的静态代码块");

    }

    {

    System.out.println("子类的非静态代码块");

    }

    Son() {

    System.out.println("子类的构造函数");

    }public static voidmain(String[] args) {

    System.out.println("new子类前的main方法");newSon();

    System.out.println("new子类后的main方法");

    }

    }

    5527f221d5a4258c5504a73f0f42a2fd.png

    总结:

    在继承了父类的子类Class中的执行顺序:

    父类的静态代码块>子类的静态代码块>new 对象前的main方法顺序执行>父类的非静态代码块>父类的构造函数>子类的非静态代码块>子类的构造函数>new 对象后的main方法顺序执行

    3.在父类的Class中测试继承了父类的子类Class

    public classFather {static{

    System.out.println("父类的静态代码块");

    }

    {

    System.out.println("父类的非静态代码块");

    }

    Father() {

    System.out.println("父类的构造函数");

    }public static voidmain(String[] args) {

    System.out.println("new子类前的main方法");newSon();

    System.out.println("new子类后的main方法");

    }

    }

    ac6dc99d57e66bd16064c229a0b25541.png

    总结:

    在父类的Class中测试继承了父类的子类Class中的执行顺序:

    父类的静态代码块>new 对象前的main方法顺序执行>子类的静态代码块>父类的非静态代码块>父类的构造函数>子类的非静态代码块>子类的构造函数>new 对象后的main方法顺序执行

    第3个(在父类的Class中测试继承了父类的子类Class)和第2个(在继承了父类的子类Class中测试)对比:

    f6ba8b2857259177114911ecf8d09ad1.png

    4c9d2374ec95d83a44eb7b5a4e006e06.png

    左图是在父类中new 子类然后执行main方法,右图是子类中new 子类然后执行main方法

    可以看出来,父类new 子类之前,先执行父类的静态代码块,然后main函数里面的代码顺序执行,直到new 了子类,然后执行子类的静态代码块,然后父类非静态代码块>父类构造函数>子类非静态代码块>子类构造函数>new子类后的main方法顺序执行 在父类中执行了main方法,本身父类执行main方法就会执行一次静态代码块,但是在父类中main方法new了一次子类,按继承关系,父类中的静态代码块应该还会执行,但是控制台中却没有打印,这就是因为静态代码块的特征的原因所致,随着类的加载而执行,而且只执行一次.

    如果还是有疑问,则看一下代码:

    d6dc74cf725f399df0c5527b71cd8a8c.png

    展开全文
  • 调用静态代码。 静态static是属于类。 1、静态方法只能访问静态成员(非静态可以自由访问静态或非静态成员) ... 当类没有构造函数,依然需要初始化的工作时候,可以使用static{ 初始化工作 }
     调用静态代码块。 静态static是属于类的。
    1、静态方法只能访问静态成员(非静态可以自由访问静态或非静态成员)
    2、静态方法中不可以使用this和super关键字
    3、主函数是静态的

    static {
    静态代码块
    }

    特点:
    1、随着类的加载而执行
      2、只执行一次
     
      当类没有构造函数,依然需要初始化的工作的时候,可以使用static{ 初始化工作 }
     
      ------------构造代码块(非静态代码块)-------------------------
      在创建对象之前执行,创建一次对象执行一次。它的作用:可以给所有对象进行初始化。
     
      类加载 -- 静态代码块 -- 代码块 -- 构造器
     
     
      局部代码块: 在函数中的代码块 。作用:限定函数中的局部变量的生命周期,
      就是局部变量作用域。
    展开全文
  • Java中静态代码块、代码块和构造函数执行顺序概念静态...执行时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块,在每个对象生成时都会被执行一次,它可以初始化类实例变量。非静态初始化块会在构造
  • java中静态代码详解

    2019-08-10 10:18:28
    静态代码块的特点吗,随着类的加载而执行,而且只执行一次,可以使得静态代码块中的代码只执行一次,不需要每次调用这个变量都给它赋值。 静态代码块:执行...执行的时候如果有静态初始化块,先执行静态初始化块...
  • 在javaweb学习中遇到了要去读取properties文件情况在dao层建立了一个BaseDao用来读取properties 进而操作数据库。...静态代码块:执行优先级高于非静态的初始化块,它会在类初始化时候执行一次...
  • 代码:为属性初始化 1.语法格式 【修饰符】class 类名【extends 父类】 { 非静态代码 } static{ 静态代码 } 2.执行的特点 (1)在创建的时候自动执行,每创建一个对象就执行一次,如果有多个代码,就...
  • 027、JAVA静态代码

    2020-02-27 10:59:53
    执行优先级高于非静态的初始化块,它会在类初始化时候执行一次,执行完成便销毁,它仅能初始化类变量,而不能调用非静态成员变量和方法,即static修饰数据成员。 静态代码块写法, static{ } 三、注意: ...
  • java静态代码详解

    2020-11-15 23:14:52
    今天在项目中看到这行代码,静态代码块,很久没用静态代码块了,今天来复习一下, 依旧按照为什么?... 静态代码块:执行优先级高于非静态的初始化块,它会在类初始化时候执行一次,执行完成便销毁...
  • 静态代码

    2015-04-29 15:38:50
    静态代码: 格式 static{ 静态代码执行语句;...静态代码不能调用非静态成员 class StaticCode{ static{ System.out.println("a"); } } public class StaticCodeDemo { static{
  • Java-静态代码

    2019-10-04 01:58:29
    Java-静态代码特点: 1,随着类载入而运行(载入内存),仅仅运行一次,...4,可是构造代码能够使用非静态成员变量 二 静态代码格式: static { 代码 } class StaticCode { static { ...
  • java代码结构使用

    2021-02-27 09:22:04
    java代码块的使用代码块的特点代码块的用法静态代码块非静态代码块代码块的使用对属性赋值的顺序 文章内容选自尚硅谷,jdk8,eclipse环境 代码块的特点 代码块属于类的内部成员之一,只可以用static关键字来修饰。...
  • 代码块的作用:用来初始化类或对象的信息 声明的位置:类中方法外 声明的格式: 类{ ...执行的特点:只执行一次,优先于非静态代码块和构造器执行,在类加载和初始化时执行 作用:为静态属性赋值 ...
  • JAVA中 代码 { }

    2020-08-27 11:20:48
    代码块: ...静态代码块的执行优先于非静态代码块的执行 静态代码块中只能调用静态的属性 作用:初始化类的一些信息(属性) 5.非静态代码块 可以写 输出语句,方法 随着对象的创建二执行 每造一个对象,
  • 代码

    2021-03-13 20:48:58
    特点:如果一个类中定义了多个静态代码块,则按照声名的先后顺序执行,静态代码块的执行要先于非静态代码块的执行。 2. 非静态代码块 执行:随着对象的创建而执行。 作用:可以在创建对象时,对对象的属性等进行初始...
  • 静态代码块的执行要优先于非静态代码块的执行 静态代码块内只能调用静态的属性、静态的方法,不能调用非静态的结构 非静态代码块: 内部可以输出语句 随着对象的创建而执行 每创建一个对象就执行一次
  • 代码要总结的感觉不是很多,大部分主要是实际应用吧,以后用到再写 代码:类的第四个成员 1.代码作用:用来初始化类,对象的信息...其实代码和其他结构在静态非静态方面的特点类似,这里不写了 main方法: M...
  • Java中static学习

    2020-05-19 21:29:27
    static 1.被static修饰的方法有两种调用方式,一是new 对象调用,而是类名直接调用。 2.访问静态方法的特点 静态的不能直接访问非静态...使用场景:当我们初始化变量的时候,只要求我们初始化一次,可供后面的使用 ...
  • 3.2 内部类

    2020-02-22 06:32:25
    内部类非静态内部类静态内部类匿名内部类局部内部类 非静态内部类 特点 非静态内部类必须寄存于一个...非静态内部类不能有静态方法、静态属性和静态初始化块。 外部类静态方法、静态代码块不能访问非静态内部类。...
  • (昨天没有学习,我有罪) Java从遗忘到入门——Day03内部类非静态内部类静态内部类匿名内部类局部内部类...非静态内部类不能有静态方法、静态属性和静态初始化块。 外部类静态方法、静态代码块不能访问非静态内部...
  • java中static详解

    2020-06-09 20:48:16
    static可以修饰 1.方法。 2.成员变量(属性)。 3.代码(不能出现在方法内部,在类加载时候执行,只执行一次)。...而非静态变量是对象所拥有,在创建对 象时候被初始化,存在多个副本,各个对象拥有副本互
  • Java内部类

    2021-03-02 09:21:17
    可以访问外部类所有成员,但是自己不能拥有静态成员(静态变量、静态初始化块、静态方法)。 静态内部类 可以拥有静态成员,但是不能访问外部类的非静态成员。 基本使用 class Outer{ public Inner test1 = new ...
  • 3

    2020-11-29 22:18:09
    实例化一个对象时,先后构造静态成员变量,静态初始化块,成员变量,初始化块,构造方法。 4.类static字段与static字段区别是什么?什么情况应该使用static修饰符? 当使用static修饰数据成员时,此时不单独...
  • 第三次作业

    2020-10-13 13:22:36
    实例化一个对象时,先后构造静态成员变量,静态初始化块,成员变量,初始化块,构造方法。 4.类static字段与static字段区别是什么?什么情况应该使用static修饰符? 当使用static修饰数据成员时,此时不单独...
  • 3 2020 10 13

    2020-10-13 13:44:04
    实例化一个对象时,先后构造静态成员变量,静态初始化块,成员变量,初始化块,构造方法。 4.类static字段与static字段区别是什么?什么情况应该使用static修饰符? 当使用static修饰数据成员时,此时不单独...
  • static关键字 static静态方法就是没有this方法 通常写this时候,都是指“这个对象”或“当前对象”,而且它本身表示对当前对象引用。 用于修饰类成员方法、类...初始化的顺序先是静态对象,后是非静态对.
  • Field定义语法格式分类赋值顺序方法 Method定义语法格式方法调用注意[方法详解](第4章 面向对象编程_4_方法详解.md)构造器作用语法格式特点分类注意代码作用分类静态代码:static修饰代码块非静态代码:...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 207
精华内容 82
关键字:

非静态初始化块的特点