黑马程序员-----------static关键字
2015-09-18 21:29
405 查看
------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”,只有一份拷贝,被多个对象共享;
3.特点:
1).随着类的加载而加载
2).优先于对象存在
3).被类的所有对象共享
4).可以通过类名调用,也可以通过对象名调用;
4.static关键字注意事项:
1).在静态方法中是没有this关键字的
2).静态方法只能访问静态的成员变量和静态的成员方法
什么时候定义静态变量呢?
当该成员变量的值,每一个对象都一致时,就对该成员变量进行静态修饰。
静态变量和成员变量的区别:
1,所属范围不同。
静态变量所属于类,成员变量所属对象。
静态变量也称为:类变量;成员变量也称为实例变量。
2,调用不同。
静态变量可以被对象和类调用(一般都用类名调用)
成员变量只能被对象调用。
3,加载时期不同。
静态变量随着类的加载而加载。
成员变量随着对象的加载而加载。
4,内存存储区域不同。
静态变量存储在方法区中。
成员变量存储在堆内存中。
class Circle
{
privatedouble radius;//圆的半径。
privatestatic double pi = 3.14;//每一个圆对象中都存储一份,有点浪费内存空间。实现对象的共享。加入静态关键字修饰。
Circle(doubleradius)
{
this.radius= radius;
}
//获取圆的面积。
doublegetArea()
{
returnradius*radius*pi;
}
staticvoid show()
{
System.out.println("circleshow run.."+pi);
}
}
class CircleDemo
{
publicstatic void main(String[] args)
{
Circlec = new Circle(3);
}
}
目标:必须了解加载的顺序。
静态代码块:
特点:随着类的加载而执行,仅执行一次。
作用:给类进行初始化。
class Demo
{
staticint x = 9;//静态变量有两次初始化。 一次默认初始化,一次显示初始化。
static//静态代码块。在静态变量显示初始化以后在执行。
{
System.out.println("类加载就执行的部..."+x);
}
staticvoid show()
{
System.out.println("showrun");
}
}
class StaticCodeDemo
{
publicstatic void main(String[] args)
{
Demo.show();
Demo.show();
}
}
1.4静态方法
静态方法使用注意事项:
1,静态方法不能访问非静态的成员。
但是非静态可以访问静态成员的。
说明:静态的弊端在于访问出现局限性。好处是可以直接被类名调用。
2,静态方法中不允许出现this,super关键字。
为什么不行呢?
原理揭秘:
1,静态是随着类的加载就加载了。也是随着类的消失而消失了。
2,静态优先于对象存在,被对象共享。
3,因为静态先存在于内存中无法访问后来的对象的中的数据,所以静态无法访问非静态。
而且内部无法书写this。因为这时对象有可能不存在,this没有任何指向。
class Person
{
privateString name;
privateint age;
Person(Stringname,int age)
{
this.name= name;
this.age= age;
}
publicvoid speak()
{
System.out.println("name="+this.name+",age="+this.age);
sleep();
}
//定义一个睡觉功能。
publicstatic void sleep()
{
// System.out.println(name);
System.out.println("睡觉zzzZZZZ");
}
}
class PersonDemo
{
publicstatic void main(String[] args)
{
// Personp = new Person("lisi",20);
// p.speak();
/*
创建对象就是为了产生实例,并进行数据的封装。
而调用功能时,确没有用到这些对象中封装的数据。
该对象的创建有意义吗?虽然可以编译并运行,但是在堆内存中空间较为浪费。
不建议创建对象。那该怎么调用呢?java中的解决方案就是 使用 static关键字,这是一个成员修饰符。
被静态static修饰的方法除了可以被对象调用外,还可以被类名调用。
静态看上去很美,是不是所有的方法都静态呢?不行!
那么什么时候需要将方法定义成静态的呢?
定义功能时,如果功能不需要访问类中定义的成员变量(非静态)时,该功能就需要静态修饰。
*/
// p.sleep();
Person.sleep();
}
}
class Demo
{
intx = 4;//成员变量 1,默认初始化,2,显示初始化。
{//构造代码块。只要创建对象就会被调用。给所有对象初始化,构造函数只给对应的对象针对性的初始化。
//这里面可以定义不同构造函数的共性代码。
System.out.println("coderun..."+x);
// System.out.println("----->hahah");
}
Demo()
{
System.out.println("demorun");
}
Demo(intx)
{
System.out.println("demorun...."+x);
// System.out.println("----->hahah");
}
}
class ConstructorCodeDemo
{
publicstatic void main(String[] args)
{
newDemo();
newDemo(5);
{//局部代码块,作用:就可以控制局部变量的生命周期。
intx = 5;
System.out.println("局部代码块..."+x);
}
System.out.println("over...");
}
}
public static int k = 0;
public static Demo2 t1 = new Demo2("t1");
public static Demo2 t2 = new Demo2("t2");
public static int i = print("i");
public static int j = print("j");
public static int n = 99;
{
print("constructor code");
}
static {
print("static code");
}
public static int print(String s) {
System.out.println("i="+i +" "+s+ " k=" + k + " n=" + n + " j=" + j);
++i;
++k;
++n;
return i;
}
public Demo2(String string) {
print(string);
}
public static void main(String[] args) {
Demo2 d=new Demo2("T");
}
}
输出结果:
i=0 constructor code k=0 n=0 j=0
i=1 t1 k=1 n=1 j=0
i=2 constructor code k=2 n=2 j=0
i=3 t2 k=3 n=3 j=0
i=4 i k=4 n=4 j=0
i=5 j k=5 n=5 j=0
i=6 static code k=6 n=99 j=6
i=7 constructor code k=7 n=100 j=6
i=8 T k=8 n=101 j=6
1 static关键字
1.1static的特点
1.static关键字:静态的,全局的。2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”,只有一份拷贝,被多个对象共享;
3.特点:
1).随着类的加载而加载
2).优先于对象存在
3).被类的所有对象共享
4).可以通过类名调用,也可以通过对象名调用;
4.static关键字注意事项:
1).在静态方法中是没有this关键字的
2).静态方法只能访问静态的成员变量和静态的成员方法
1.2静态变量及其与成员变量的区别
静态变量:什么时候定义静态变量呢?
当该成员变量的值,每一个对象都一致时,就对该成员变量进行静态修饰。
静态变量和成员变量的区别:
1,所属范围不同。
静态变量所属于类,成员变量所属对象。
静态变量也称为:类变量;成员变量也称为实例变量。
2,调用不同。
静态变量可以被对象和类调用(一般都用类名调用)
成员变量只能被对象调用。
3,加载时期不同。
静态变量随着类的加载而加载。
成员变量随着对象的加载而加载。
4,内存存储区域不同。
静态变量存储在方法区中。
成员变量存储在堆内存中。
class Circle
{
privatedouble radius;//圆的半径。
privatestatic double pi = 3.14;//每一个圆对象中都存储一份,有点浪费内存空间。实现对象的共享。加入静态关键字修饰。
Circle(doubleradius)
{
this.radius= radius;
}
//获取圆的面积。
doublegetArea()
{
returnradius*radius*pi;
}
staticvoid show()
{
System.out.println("circleshow run.."+pi);
}
}
class CircleDemo
{
publicstatic void main(String[] args)
{
Circlec = new Circle(3);
}
}
1.3 静态代码块
需求:类一加载,需要做一些动作。不一定需要对象。目标:必须了解加载的顺序。
静态代码块:
特点:随着类的加载而执行,仅执行一次。
作用:给类进行初始化。
class Demo
{
staticint x = 9;//静态变量有两次初始化。 一次默认初始化,一次显示初始化。
static//静态代码块。在静态变量显示初始化以后在执行。
{
System.out.println("类加载就执行的部..."+x);
}
staticvoid show()
{
System.out.println("showrun");
}
}
class StaticCodeDemo
{
publicstatic void main(String[] args)
{
Demo.show();
Demo.show();
}
}
1.4静态方法
静态方法使用注意事项:
1,静态方法不能访问非静态的成员。
但是非静态可以访问静态成员的。
说明:静态的弊端在于访问出现局限性。好处是可以直接被类名调用。
2,静态方法中不允许出现this,super关键字。
为什么不行呢?
原理揭秘:
1,静态是随着类的加载就加载了。也是随着类的消失而消失了。
2,静态优先于对象存在,被对象共享。
3,因为静态先存在于内存中无法访问后来的对象的中的数据,所以静态无法访问非静态。
而且内部无法书写this。因为这时对象有可能不存在,this没有任何指向。
class Person
{
privateString name;
privateint age;
Person(Stringname,int age)
{
this.name= name;
this.age= age;
}
publicvoid speak()
{
System.out.println("name="+this.name+",age="+this.age);
sleep();
}
//定义一个睡觉功能。
publicstatic void sleep()
{
// System.out.println(name);
System.out.println("睡觉zzzZZZZ");
}
}
class PersonDemo
{
publicstatic void main(String[] args)
{
// Personp = new Person("lisi",20);
// p.speak();
/*
创建对象就是为了产生实例,并进行数据的封装。
而调用功能时,确没有用到这些对象中封装的数据。
该对象的创建有意义吗?虽然可以编译并运行,但是在堆内存中空间较为浪费。
不建议创建对象。那该怎么调用呢?java中的解决方案就是 使用 static关键字,这是一个成员修饰符。
被静态static修饰的方法除了可以被对象调用外,还可以被类名调用。
静态看上去很美,是不是所有的方法都静态呢?不行!
那么什么时候需要将方法定义成静态的呢?
定义功能时,如果功能不需要访问类中定义的成员变量(非静态)时,该功能就需要静态修饰。
*/
// p.sleep();
Person.sleep();
}
}
2 构造代码块
用于给所有的对象初始化。很少用并很少见。class Demo
{
intx = 4;//成员变量 1,默认初始化,2,显示初始化。
{//构造代码块。只要创建对象就会被调用。给所有对象初始化,构造函数只给对应的对象针对性的初始化。
//这里面可以定义不同构造函数的共性代码。
System.out.println("coderun..."+x);
// System.out.println("----->hahah");
}
Demo()
{
System.out.println("demorun");
}
Demo(intx)
{
System.out.println("demorun...."+x);
// System.out.println("----->hahah");
}
}
class ConstructorCodeDemo
{
publicstatic void main(String[] args)
{
newDemo();
newDemo(5);
{//局部代码块,作用:就可以控制局部变量的生命周期。
intx = 5;
System.out.println("局部代码块..."+x);
}
System.out.println("over...");
}
}
3.static和构造代码块的执行先后顺序
public class Demo2 {public static int k = 0;
public static Demo2 t1 = new Demo2("t1");
public static Demo2 t2 = new Demo2("t2");
public static int i = print("i");
public static int j = print("j");
public static int n = 99;
{
print("constructor code");
}
static {
print("static code");
}
public static int print(String s) {
System.out.println("i="+i +" "+s+ " k=" + k + " n=" + n + " j=" + j);
++i;
++k;
++n;
return i;
}
public Demo2(String string) {
print(string);
}
public static void main(String[] args) {
Demo2 d=new Demo2("T");
}
}
输出结果:
i=0 constructor code k=0 n=0 j=0
i=1 t1 k=1 n=1 j=0
i=2 constructor code k=2 n=2 j=0
i=3 t2 k=3 n=3 j=0
i=4 i k=4 n=4 j=0
i=5 j k=5 n=5 j=0
i=6 static code k=6 n=99 j=6
i=7 constructor code k=7 n=100 j=6
i=8 T k=8 n=101 j=6
相关文章推荐
- java程序员
- 职场新人完全转型七大要素
- 我的求职路
- 野生程序员的故事
- 黑马程序员_java基础_多线程
- 面试题用两个栈构造一个队列和用两个队列构造一个栈
- 黑马程序员---Java基础---多线程
- 面试经之一道淘汰85%面试者的百度开发者面试题
- 【转】测试职业思考:如何成为一名优秀的软件测试工程师
- 创新工场2016校园招聘 面试
- 如何写面向互联网公司的求职简历
- 黑马程序员-Java基础学习-反射技术
- 黑马程序员_java面向对象_多态和异常
- iOS面试题及答案
- iOS 面试题
- iOS 如何面试
- iOS 进阶面试题-Block部分
- 黑马程序员——ios开发基础之OC中的面向对象以及对象特性
- 黑马程序员_java面向对象_抽象类和接口
- 二叉树中的那些常见的面试题