精华内容
下载资源
问答
  • 1、静态方法只能访问静态成员(非静态可以自由访问静态或非静态成员) 2、静态方法中不可以使用this和super关键字 3、主函数是静态的 static { 静态代码块 } 特点: 1、随着类的加载而执行  2、只执行一...
     调用静态代码块。 静态static是属于类的。
    1、静态方法只能访问静态成员(非静态可以自由访问静态或非静态成员)
    2、静态方法中不可以使用this和super关键字
    3、主函数是静态的

    static {
    静态代码块
    }

    特点:
    1、随着类的加载而执行
      2、只执行一次
     
      当类没有构造函数,依然需要初始化的工作的时候,可以使用static{ 初始化工作 }
     
      ------------构造代码块(非静态代码块)-------------------------
      在创建对象之前执行,创建一次对象执行一次。它的作用:可以给所有对象进行初始化。
     
      类加载 -- 静态代码块 -- 代码块 -- 构造器
     
     
      局部代码块: 在函数中的代码块 。作用:限定函数中的局部变量的生命周期,
      就是局部变量作用域。
    展开全文
  • 为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。 2. 对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享!! 3. 一般用“类名.类属性/方法”来调用。(也可以通过...

    一.static关键字

      在类中,用static声明的成员变量为静态成员变量,也称为类变量。 类变量的生命周期和类相同,在整个应用程序执行期间都有效。它有如下特点:

      1. 为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。

      2. 对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享!!

      3. 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)

      4. 在static方法中不可直接访问非static的成员。

    核心要点:

    static修饰的成员变量和方法,从属于类。

    普通变量和方法从属于对象的。

    351a312865106a1b98da851f0a929194.png

    f40c2e5a58f94b44c1c7708a40e0a633.png

    运行结果:

    d0dd0451173d6e38613d1d71f29a1857.png

    二.java中的数据参数传值机制

    Java中,方法中所有参数都是“值传递”,也就是“传递的是值的副本”。 也就是说,我们得到的是“原参数的复印件,而不是原件”。因此,复印件改变不会影响原件。

    · 基本数据类型参数的传值

      传递的是值的副本。 副本改变不会影响原件。

    · 引用类型参数的传值

      传递的是值的副本。但是引用类型指的是“对象的地址”。因此,副本和原参数都指向了同一个“地址”,改变“副本指向地址对象的值,也意味着原参数指向对象的值也发生了改变”。

    7a476cce915241dc1deac1895d4e107b.png

    04883e28c8b9490c572e8f2adadcc29d.png

    三.package和import

    包机制是Java中管理类的重要手段。 开发中,我们会遇到大量同名的类,通过包我们很容易对解决类重名的问题,也可以实现对类的有效管理。 包对于类,相当于文件夹对于文件的作用。

    我们通过package实现对类的管理,package的使用有两个要点:

      1. 通常是类的第一句非注释性语句。

      2. 包名:域名倒着写即可,再加上模块名,便于内部管理类。

    注意事项:

      1. 写项目时都要加包,不要使用默认包。

      2. com.gao和com.gao.car,这两个包没有包含关系,是两个完全独立的包。只是逻辑上看起来后者是前者的一部分。

    JDK中的主要包有如下这些:

    e15b0e6ffd822ad9168de88da76599a9.png

    JDK中常用的包:

    * 除了java.lang下的类或接口可以不用导包直接使用外,其他包下的类或接口必须导包后才能使用。

    * 1.java.lang包:java核心的类和接口。可以直接使用,无需导包。

    * 2.java.awt包/javax.swing包:窗口相关的类或接口

    * http://3.java.io包:输入输出相关的类或接口

    * http://4.java.net包:网络通信相关的类或接口

    * 5.java.utll包:工具包

    * 6.java.sql包:数据库操作相关的类和接口

    *

    * 导包:快捷键ctrl+shift+o

    * 1. import 包名.类名;

    * 2. import 包名.*;(将该包下的所有类全部导入)

    如果我们要使用其他包的类,需要使用import导入,从而可以在本类中直接通过类名来调用,否则就需要书写类的完整包名和类名。import后,便于编写代码,提高可维护性。

    注意要点:

      1. Java会默认导入java.lang包下所有的类,因此这些类我们可以直接使用。

      2. 如果导入两个同名的类,只能用包名+类名来显示调用相关类:

    07a50ace051137cd63b1eef94947fed8.png

    四.面向对象的继承

    继承让我们更加容易实现类的扩展。 比如,我们定义了人类,再定义Boy类就只需要扩展人类即可。实现了代码的重用,不用再重新发明轮子(don’t reinvent wheels)。

    从英文字面意思理解,extends的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如:

    006cedf62986914c2d71b7c479f5ed96.png

    上图中,哺乳动物继承了动物。意味着,动物的特性,哺乳动物都有;在我们编程中,如果新定义一个Student类,发现已经有Person类包含了我们需要的属性和方法,那么Student类只需要继承Person类即可拥有Person类的属性和方法。

    • instanceof是二元运算符,左边是对象,右边是类;当对象是右面类或子类所创建对象时,返回true;否则,返回false。

    a305fc2ab965f79db67a09ba8db45c74.png

    204705bafe606bb5006d988949c69f19.png

    7d66eb8e267caa73c8028d5ef26a62dd.png

    五.方法的重写

    子类通过重写父类的方法,可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

    方法的重写需要符合下面的三个要点:

    1.“==”: 方法名、形参列表相同。

    2.“≤”:返回值类型和声明异常类型,子类小于等于父类。

    3.“≥”: 访问权限,子类大于等于父类。

    7c33e5f9bf92644eca4005f331c88350.png
    展开全文
  • 静态成员

    2019-08-25 21:42:46
    非静态成员函数也可以操作静态数据成员 一、静态成员的特点: (1)static数据成员在类的内部声明,但只能在类的外部定义,在类的外部不能指定static,在类的定义时候进行初始化; (2)static数据成员只能在类的外部...

    静态成员不属于对象,是类的共享成员
    静态数据成员要在类外定义和初始化
    非静态成员函数也可以操作静态数据成员

    一、静态成员的特点:

    (1)static数据成员在类的内部声明,但只能在类的外部定义,在类的外部不能指定static,在类的定义时候进行初始化;

    (2)static数据成员只能在类的外部进行初始化(特例:当整型const、static数据成员被常量表达式初始化时,就可以在类的内部进行初始化,但还需要在外部进行定义)。

    (3) static数据成员可以是该成员所属的类类型,而非static数据成员只能自身类的引用或者指针。

    (4)static数据成员可以用作类成员函数的默认实参

    (5)static数据成员的值可以改变

    二、静态成员和非静态成员的区别:

    (1) 静态变量使用 static 修饰符进行声明,在类被实例化时创建,通过类和对象都可以进行访问;

    (2)不带有 static 修饰符声明的变量称做非静态变量,在对象被实例化时创建,通过对象访问;

    (3) 一个类的所有实例的同一静态变量都是同一个值,同一个类的不同实例的同一非静态变量可以是不同的值。

    (4) 静态函数的实现里不能使用非静态成员,如非静态变量、非静态函数等。

    三、静态成员函数的特点:

    (1) static 成员函数没有 this 形参,它可以访问所属类的 static 成员,但不能访问非 static 成员。
    (2)static成员函数既可以在类的内部定义,也可以在类的外部定义,在外部定义时,不能重复指定static保留字。

    (3)static成员函数不能声明为虚函数,不能实现动态绑定

    (4)static 成员函数不能声明为const,因为const是针对this是不是const而言的

    (5)构造函数、析构函数不能为静态函数。

    展开全文
  • 在C++代码中static 关键字随处可见,到底有什么用呢?下面结合类class举几个简单的例子。 文章目录类中静态成员变量与静态成员函数的特点静态成员...(非静态成员变量隶属于特定的对象) 类内声明,类外初始化。 静

    在C++代码中static 关键字随处可见,到底有什么用呢?下面结合class举几个简单的例子。

    类中静态成员变量与静态成员函数的特点

    在类中以static 修饰的变量以及函数称为静态成员变量和静态成员函数,特点下:

    静态成员变量:

    1. 在编译阶段分配内存,存储于全局区。
    2. 所有对象共享一份数据,因此不属于特定哪个某个对象。(非静态成员变量隶属于特定的对象)
    3. 类内声明,类外初始化。

    静态成员函数:

    1. 所有对象共享同一个函数,因此不属于特定哪个某个对象。
    2. 静态成员函数只能访问静态成员变量。

    静态成员变量示例代码

    上菜!!!
    让我们定义一个Sta 的类(class),它有两个静态成员变量,_a和_count还有一个非静态成员函数display用于打印数据。

    #include <iostream>
    #include <string>
    #include <typeinfo>
    using namespace std;
    
    class Sta 
    {
    public:
    	Sta() { _count++; }
    	void display() { cout << typeid(*this).name() << _count << " 's " << "static member _a is " << _a << endl; }
    	static int _a; //类内声明
    	static int _count;
    };
    
    int Sta::_a = 0; //类外初始化,初始化不加static关键字,否则编译不通过
    int Sta::_count = 0;
    
    int main()
    {
    	Sta sta1; //实例化对象
    	sta1.display(); //调用打印display打印输出_a
    	Sta sta2; //同上
    	sta2.display(); //同上
    	sta2._a = 520;  //通过对象sta2访问并修改_a!!!
    	cout << "sta1's static member _a: " << sta1._a << endl; //通过sta1获取_a的值,再次打印观察结果
        cout << "***************************************" << endl;
    	cout << Sta::_a; //用类名的方式访问静态成员变量,无需创建对象
    	
    	// 静态成员变量存储在全局区,所有对象共享一份,不属于任何一个对象!
    	return 0;
    }
    

    先不管_count,我们看看_a的变化。静态成员变量_a在类外初始化为0,主函数先后创建两个类,创建的同时display( )打印出来的_a均为0,然后通过sta2访问并将_a的值修改为520,再通过sta1获取_a的值并打印输出。

    如果_a是一般的成员变量,即非静态成员变量的话,sta2修改它的值是不会改变sta1中_a的值。因为每个对象都有自己的成员变量,它们并不共享切毫无关联!但一开始sta1.display()出来的_a是0,通过sta2将_a修改成520之后,再打印出来的sta1._a值也变为了520,可见这两份数据有关联,准确地说这两份数据是同一份,即对象sta1、sta2共享同一份_a数据。

    既然静态成员不隶属于任何一个对象,那么我们能否不像非静态成员变量那样通过对象来访问呢?(sta1._a)答案是肯定的!

    下面这行就是直接通过类名访问静态成员变量,不需要创造任何对象!但要说清楚该变量是哪个作用域下的(Sta::)。

    cout << Sta::_a; //用类名访问静态成员变量,同样可以输出520
    

    静态成员变量就像一辆共享单车,10个能扫码开锁的人好比是10个对象,这辆车不属于任何一个人(对象),但是每个人都能改变这辆车的状态,骑、在哪骑,停、停在哪…

    同样作为静态成员变量的_count也不属于任何一个对象,无论哪个对象对其作出修改,这份独一无二的数据就会改变。我通过构造函数对它进行自增运算,Sta每构造一个新的对象count就会+1,一直累加下去。

    typeid运算符

    其中typeid运算符会返回一个type_info对象,该对象的name( )函数会返回const char*,用以表示类名。typeid运算符接收一个对象作为参数,使用该运算符前记得包含头文件<typeinfo>。通过得到的类名后面追加累加的_count就可以打印不同对象的名称了。(严格来说并不是对象的名称,我这里只是用来做实验说明这个效果,哈哈~~~)

    静态成员函数示例代码

    静态成员函数特点与静态成员变量类似,所有对象共享一份,不属于任何一个对象!同样也可以不用创建对象,通过类名访问

    上面介绍特点的时候说过,静态成员函数只能访问静态成员变量,因此它不能访问非静态成员变量了,这又是为什么呢?

    先看看这段代码,有没有问题?

    class Sta
    {
    public:
    	int _b;
    
    private:
    	static int s_a; //类内声明
    	//static int sta_display() { return s_a; }
    	static int sta_display() { return _b; }
    
    };
    
    int Sta::s_a = 0; //类外初始化,初始化不加static关键字,否则编译不通过
    
    int main()
    {
    
    	return 0;
    }
    

    答案还是肯定的!编译器会提示这么一个错误。
    在这里插入图片描述
    意思就是非静态成员变量必须通过对象来访问。因为静态成员函数不属于任何对象,因此它提供不了一个特定的对象来访问_b,所以报错了。

    但常识告诉我们sta_display( )作为Sta类中的成员函数理应可以访问成员变量_b。我们看看常识告诉我们的操作是怎么实现的。我们再来一个非静态成员函数display( )就可以正常访问_b了。(注意看sta_display( )那行_b下面是有红色波浪线,说明有错误)
    在这里插入图片描述
    事实上,非静态成员函数也只有一份,那它怎么提供特定对象呢?当非静态成员函数display( )访问_b时,其实编译器会自动提供this指针,即转化成这样

    	int display() { return this->_b; }
    

    this指针

    静态成员函数无需通过对象调用(类名即可),但非静态成员函数必须通过特定对象来调用,当实例化出来的对象调用该函数时,this指针会指向该对象,即this指针指向被调用的成员函数所属的对象!。自然也可以为非静态成员变量_b提供特定对象了(this指针嘛)。而静态成员函数没有this指针,编译器也不知道你要访问哪个_b,当然会出错了!

    有人会问静态成员函数不会自动提供this指针吗?答案终于是否定了。我们假设它会自动提供this指针的话…那么静态成员函数如果用类名(作用域)这种方式访问的话,没有创建任何对象哦,那请问this指针指向谁?逻辑上行不通了。

    所以静态成员函数只能老老实实访问静态成员变量反正静态成员变量不属于任何对象,正好静态成员函数也不能提供任何对象!上面代码注释行是行得通的!

    //static int sta_display() { return s_a; }
    

    访问权限

    补充一点:若像上面那个Sta类那样将静态成员变量、函数声明为private(私有作用域)的话,类外是不可访问的。虽然它们是共享的,但也有访问权限。既开放(类内),又关闭(类外)!真银杏~~~

    展开全文
  • 3.2 内部类

    2020-02-22 06:32:25
    内部类非静态内部类静态内部类匿名内部类局部内部类 非静态内部类 特点 非静态内部类必须寄存于一个...非静态内部类不能有静态方法、静态属性和静态初始化块。 外部类的静态方法、静态代码块不能访问非静态内部类。...
  • Java中static的学习

    2020-05-19 21:29:27
    静态的属于类,非静态属于对象,类一旦加载,那么静态的就会跟着方法直接进内存,是优先于对象存在的 使用:创建对象,再调用非静态方法 静态能访问静态 非静态的能直接访问静态的 3.静态代码块 static{ 代码 } ...
  • 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修饰数据成员时,此时不单独...
  • 2—static

    2019-04-05 15:39:14
    静态这哥们不属于某一个类的实列化对象,他是属于类的,他具有三个鲜明的特点(1)在类加载的时候,就进行创建和初始化或执行代码。(2)他是被所有对象共享的。(3)一个类只有一份 1—静态变量 static变量也称作...
  • java代码块结构的使用

    2021-02-27 09:22:04
    java代码块的使用代码块的特点代码块的用法静态代码块非静态代码块代码块的使用对属性赋值的顺序 文章内容选自尚硅谷,jdk8,eclipse环境 代码块的特点 代码块属于类的内部成员之一,只可以用static关键字来修饰。...
  • 特点:1、只属于类,最好在类外单独初始化2、只能被静态成员函数访问,静态成员函数,不能调用非静态成员函数和数据成员3、不属于任何对象,属于类 运算符重载 一元运算符重载:只对一个操作数操作(如-,负号,++...
  • static关键字 static静态方法就是没有this的方法 通常写this的时候,都是指...非静态成员变量和成员方法是属于对象的,而被static修饰的成员变量及方法并不属于特定的对象。 初始化的顺序先是静态对象,后是非静态对.
  • 【04-面向对象(上)】

    2018-07-03 21:41:30
    •用static修饰的初始化块为静态初始化块,由于是静态的,所以是属于类,当类加载时,就执行静态初始化块 ,  但执行一个子类时,最先执行其最顶层父类的静态初始化, •初始化块是属于实例 的。只要创建一次...
  • JVM 关键字 内存图

    2020-04-11 18:19:57
    JVM java虚拟机分为五个区域 静态的资源在方法区加载类的时候加载 非静态的 在new对象的时候加载 栈内存: 用来运行java...对象所属于类的所有成员变量 随着对象的出现在堆内存中初始化加载 堆中数据的特点 : 不赋值...
  • static关键字

    2019-09-08 21:59:17
    为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。 对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享! 一般用“类名.类属性/方法”来调用。(也可以通过对象引用...
  • static方法能否重写

    2020-11-02 11:25:06
    1. 为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显式初始化。 2. 对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享!! 3. 一般用“类名.类属性/方法”来调用。(也可以通过...
  • 【05-面向对象(下)】

    2018-07-03 21:42:31
    •对于类属性而言,要么在静态初始化中初始化,要么在声明该属性时初始化。 •对于实例属性,要么在普通初始化块中指定初始值。要么在定义时、或构造器中指定初始值。 final修饰局部变量 •使用final修饰...
  • 由于采用了函数模块式的结构, C语言易于实现结构程序设计。使程序的层次结构清晰,便于程序的编写、阅读、调试。  在C语言中可从不同的角度对函数分类。 1. 从函数定义的角度看,函数可分为库函数和用户...
  • 在这一章的最后,我们将更贴近地观察初始化过程:自动成员初始化、指定成员初始化初始化的顺序、static(静态初始化以及数组初始化等等。 (5) 第5章:隐藏实现过程 本章要探讨将代码封装到一起的方式,以及在库...
  • 静态变量优化;电量性能优化;view控件异常销毁保存重要信息优化;去除淡黄色警告优化;使用注解替代枚举优化;glide加速优化;多渠道打包优化状态管理切换优化;TrimMemory和LowMemory优化;轮询操作优化;去除重复...
  • 在这一章的最后,我们将更贴近地观察初始化过程:自动成员初始化、指定成员初始化初始化的顺序、static(静态初始化以及数组初始化等等。 (5) 第5章:隐藏实现过程 本章要探讨将代码封装到一起的方式,以及...
  • initialize:表示是否初始化,默认是false loader:可以指定一个类加载器加载字节码文件 2. 全限定类名.class 3. 对象名.getClass() Class类中方法newInstance():创建...
  • 创建对象包括声明、实例化和初始化三方面的内容。通常的格式为 : 1. 声明对象 对象声明实际上是给对象命名,也称定义一个实例变量。对象声明的一般格式为: type name 其中,type 是一个类的类名,用它声明的对象将...
  • 根据快速原型法的特点,说明它特别适合于开发探索型、实验型的软件。 3. 如何画分层数据流图? 答: 总的原则是:至顶而下,逐层分解(画分层数据流图)。 比较复杂的系统不能画在一张纸上,逐层分解的画法可以...
  • java面试宝典

    2013-02-28 16:04:01
    141、使用useBean标志初始化BEAN时如何接受初始化参数 36 142、使用JSP如何获得客户浏览器的信息? 36 143、能象调用子程序一样调用JSP吗? 36 144、当我重编译我的JSP使用的一个类后,为什么JVM继续使用我的老CLASS...
  • Thinking.In.Java

    2012-03-21 22:35:53
    在这一章的最后,我们将更贴近地观察初始化过程:自动成员初始化、指定成员初始化初始化的顺序、static(静态初始化以及数组初始化等等。 (5) 第5章:隐藏实现过程 本章要探讨将代码封装到一起的方式,以及在库...
  • 千方百计笔试题大全

    2011-11-30 21:58:33
    141、使用useBean标志初始化BEAN时如何接受初始化参数 36 142、使用JSP如何获得客户浏览器的信息? 36 143、能象调用子程序一样调用JSP吗? 36 144、当我重编译我的JSP使用的一个类后,为什么JVM继续使用我的老CLASS...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    11.3 静态和非静态的方法.129 11.4 方法的重载.130 11.5 操作符重载.134 11.6 小 结.137 第十二章 域 和 属 性 .139 12.1 域 .139 12.2 属 性 .143 12.3 小 结 .146 第十三章 事件和索引指示器 .148 ...
  • C#微软培训资料

    2014-01-22 14:10:17
    11.3 静态和非静态的方法.129 11.4 方法的重载.130 11.5 操作符重载.134 11.6 小 结.137 第十二章 域 和 属 性 .139 12.1 域 .139 12.2 属 性 .143 12.3 小 结 .146 第十三章 事件和索引指示器 .148 ...

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
关键字:

属于非静态初始化特点