精华内容
下载资源
问答
  • java static关键字修饰方法

    千次阅读 2018-10-22 00:24:45
    java static关键字修饰方法1.java static关键字修饰方法的特性2.注意要点 1.java static关键字修饰方法的特性 随着类的加载而加载,在内存中也是独一份 可以直接通过“类.类方法”的方式调用 在静态的方法内部...

    1.java static关键字修饰方法的特性

    1. 随着类的加载而加载,在内存中也是独一份
    2. 可以直接通过“类.类方法”的方式调用
    3. 在静态的方法内部可以调用静态的属性或者静态的方法,而不能调用非静态的方法。反之,非静态的方法时可以调用静态属性或者方法的。
    4. demo
    public class TestStatic {
    	public static void main(String[] args) {
    		SportsMan s1 = new SportsMan("金龙",23);
    
    //		SportsMan.show();//因为这是一个普通的方法,所以不能通过类来调用
    		s1.show();
    		SportsMan.show1();
    		s1.show1();
    	}
    }
    class SportsMan{
    	//实例变量(随着对象的创建而被加载的)
    	String name;
    	int age;
    	//类变量
    	static String nation;//出生是早于属性的
    	
    	public SportsMan(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.nation = "China";
    	}
    
    	public void show() {
    		System.out.println("nation:" + nation);
    		info();
    		System.out.println("age" + this.age);
    		System.out.println("我是一名来自中国的运动员");
    	}
    	public static void show1() {
    		System.out.println("nation:" + nation);
    		info();
    //		this.show();//报错,属性为非静态
    //		System.out.println("age" + this.age);//报错,属性为非静态
    		System.out.println("我是一名来自中国的运动员");
    	}
    	public static void info() {
    		System.out.println("我是一个静态的方法!");
    	}
    }
    

    2.注意要点

    1. 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构,同时被回收也要晚于非静态结构
    2. 静态的方法内是不可以有this或者super关键字的!
    展开全文
  • 一、Static关键字修饰符  1.修饰类和变量  1) 使用static关键字来修饰的类,这个静态类里面所有的属性和方法必须是static关键字来修饰 2) 没有使用static关键字来修饰的类,也可以用static来修饰类里面的属性...

    一、Static 关键字修饰符

      1.修饰类和变量

        1) 使用static关键字来修饰的类,这个静态类里面所有的属性和方法必须是static关键字来修饰
        2) 没有使用static关键字来修饰的类,也可以用static来修饰类里面的属性和方法
        3) 使用static关键字来修饰的类,这个类不需要实例化,直接通过类名.属性/方法
        4) const 和 static 不能同时使用,readonly 和static 可以同时使用
        5) static关键字修饰的变量在程序初始化时被分配,直到程序退出前才被释放

       2.静态构造函数   

        1) 静态构造函数里面不能出现public,protected,private 修饰符,而非静态构造函数可以
           2) 静态构造函数最先被访问,只有静态构造函数被访问完了,才开始访问非静态构造函数
        3) 静态构造函数只初始化一次(只在类的第一次初始化),非静态构造函数可以访问多次
        4) 静态构造函数必须是无参数的,非静态构造函数可以有参数
        5) 静态构造函数只有一个,非静态构造函数至少有一个

          注:任何方法体都不能用static关键字来修饰

    转载于:https://www.cnblogs.com/GreatPerson/p/11041887.html

    展开全文
  • 如果父类中有一个静态的方法,子类也有一个与其方法名,参数类型,参数个数都一样的方法,并且也有static关键字修饰,那么该子类的方法会把原来继承过来的父类的方法隐藏,而不是重写。通俗的讲就是父类的方法和子类...

       静态的方法可以被继承,但是不能重写。如果父类中有一个静态的方法,子类也有一个与其方法名,参数类型,参数个数都一样的方法,并且也有static关键字修饰,那么该子类的方法会把原来继承过来的父类的方法隐藏,而不是重写。通俗的讲就是父类的方法和子类的方法是两个没有关系的方法,具体调用哪一个方法是看是哪个对象的引用;这种父子类方法也不在存在多态的性质。

    Java不推荐用对象调用static方法,这会使人混淆,请大家注意。

     

    package august31.Test6;
    
    public abstract class Animal {
        String color;
            
        public Animal() {
            super();
        }
    
        public Animal(String color) {
            this.color = color;
        }
    
        public abstract void shut();
        //cry()方法不能重写
        public static void cry(){
            System.out.println("动物会流泪。");
        }
    }
    View Code

     

    package august31.Test6;
    
    public class Dog extends Animal{
        //必须要实现父类的抽象方法
        String name;
        
        public Dog() {
            super();
        }
    
        public Dog(String name,String color) {
            super(color);
            this.name = name;
        }
        
        public void shut() {
            System.out.println("汪汪汪");
        }
    
    }
    View Code
    package august31.Test6;
    
    public class Test6 {
    
        public static void main(String[] args) {
            //Animal animal = new Animal();//不能实例化对象
            
            Dog dog = new Dog("小黄","白色");
            dog.shut();
            dog.cry();
        }
    
    }
    View Code

     

      这也是为什么abstract修饰的method是不可同时是static的原因:

      abstract修饰方法,子类需要重写去实现,主要用于各个子类的实例对象; 
      static修饰方法,则方法不属于某个对象,属于class,可用class名.方法名(),进行调用;简单的说abstract实例对象; 而static属于类。 所以static方法不能是abstract方法

    转载于:https://www.cnblogs.com/mibin/p/7459435.html

    展开全文
  • 1、使用static关键字修饰一个属性 声明为static的变量实质上就是全局变量 2、使用static关键字修饰一个方法 通常,在一个类中定义一个方法为static,那就是说,无需本类的对象即可调用此方法 3、使用static关键字...

    static关键字的作用:
    1、使用static关键字修饰一个属性
    声明为static的变量实质上就是全局变量

    2、使用static关键字修饰一个方法
    通常,在一个类中定义一个方法为static,那就是说,无需本类的对象即可调用此方法

    3、使用static关键字修饰一个类型(内部类)

    未使用static关键字前代码:

    
    public class StaticTest{
    	public static void main(String[] args){
    		Role beibei = new Role("刘备","蜀国");
    		Role fefei = new Role("张飞","蜀国");
    		Role yunchang = new Role("云长","蜀国");
    		
    		System.out.println(beibei.getInfo());
    		System.out.println(yunchang.getInfo());
    		System.out.println(fefei.getInfo());
    	}
    }
    //角色
    class Role{
    	private String name;
    	private String country;
    	public Role(String name,String country){
    		this.name = name;
    		this.country = country;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    	public String getName(){
    		return name;
    	}
    	public void setCountry(String country){
    		this.country =country;
    	}
    	public String getCountry(){
    		return country;
    	}
    	public String getInfo(){
    		return "name="+name+"country="+country;
    	}
    }
    /**
    运行结果:
    name=刘备country=蜀国
    name=云长country=蜀国
    name=张飞country=蜀国
    */
    

    三个对象会分别new出三个地址空间,存放三份相同的country=蜀国,若只想country定值蜀国,需引入静态修饰符static。

    使用static关键字后代码:

    
    public class StaticTest1{
    	public static void main(String[] args){
    		Role beibei = new Role("刘备");
    		Role fefei = new Role("张飞");
    		Role yunchang = new Role("云长");
    		
    		System.out.println(beibei.getInfo());
    		System.out.println(yunchang.getInfo());
    		System.out.println(fefei.getInfo());
    	}
    }
    //角色
    class Role{
    	private String name;
    	private static String country = "蜀国";//静态变量(全局变量)
    	public Role(String name){
    		this.name = name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    	public String getName(){
    		return name;
    	}
    	public String getInfo(){
    		return "name="+name+"country="+country;
    	}
    }
    /**
    运行结果:
    name=刘备country=蜀国
    name=云长country=蜀国
    name=张飞country=蜀国
    */
    

    静态方法区:存储静态变量,类信息(方法)

    static关键字
    1、静态变量或方法不属于对象,依赖类
    2、静态变量是全局变量,生命周期从类被加载后一直到程序结束
    3、静态变量只有存一份,在静态方法区中存储
    4、静态变量是本类所有对象共享一份
    5、建议不要使用对象名去调用静态数据,直接使用类名调用
    6、stitic修饰一个方法,那么该方法属于类,不属于对象,直接使用类名调用
    7、静态方法不能访问非静态属性和方法,只能访问静态

    展开全文
  • java static关键字修饰变量

    千次阅读 2018-10-21 16:59:10
    java static关键字1.为什么 要有static的出现?2.static修饰属性3. static修饰属性内存解析图4. static修饰属性的要点 1.为什么 要有static的出现? 当我们编写一个类的时候,其实就是在描述其对象的属性和行为,...
  • 如果有了static关键字,那么需要创建对象,直接就通过类名称来使用它。 无论是成员变量,还是成员方法。如果有了static关键字,都推荐直接使用类名称进行调用。 静态变量:类名称.静态变量 静态方法:类名称....
  • 属性(成员变量) : 实例变量 vs 类变量(static修饰的属性) static可以修饰: 属性,方法,代码块,内部类 static修饰属性(类变量): 同一个类创建的多个对象,每个对象单独拥有一份实例变量,共同拥有一份类...
  • static关键字 用法 修饰成员变量 修饰方法 静态代码块 修饰内部类 修饰内部类时可以需要外部类对象直接生成内部类实例。用法如下 代码 内部类没加static关键字,创建内部类对象需要外部类对象来完成,加上static...
  • 对待这个问题,我建议用辩证的角度去看待!首先我们来看只有final没有static的情况,也就是说每个...如果我用static关键字修饰了,不管你创建多少个实现类实例,他们都共享这个成员属性并且内存中也只会开销紧够存储
  • c语言中static关键字用法详解

    万次阅读 多人点赞 2018-04-05 18:18:14
    static关键字在c语言中比较常用,使用恰当能够大大提高程序的模块化特性,有利于扩展和维护。 但是对于c语言初学者,static由于使用灵活,并容易掌握。本文就static在c语言中的应用进行总结,供参考使用。错漏...
  • Java中的static关键字修饰的类变量是静态变量,所有以此类实例化的对象共享此变量实体. 实例化的多个对象任何一个对Static修饰的变量操作后,其他的对象指向的此变量都变化. 下面是测试代码: /** * 测试Static...
  • 下面我们先来了解一下static关键字及其用法。 static关键字 1,修饰成员变量 类,里面有属性和方法 属性里面又分局部变量,实例变量和类变量 实例变量,在创建对象的时候分配空间初始化 类变量不再属于某一个对象,它...
  • static关键字能修饰什么

    万次阅读 2018-07-25 20:17:36
    static关键字是Java中常用的关键字之一,可能最常用的就是修饰变量和方法了,但是仅仅知道这些还远远不够。问题虽然很小,但是却反映了对Java的了解程度。 static修饰变量和方法 static可以修饰变量,这个变量...
  • 如果一个成员变量使用了static关键字,那么这个变量不再属于对象自己,属于所在的类。多个对象共享同一份数据 计数自动增长,用static定义的一个变量idCounter来进行计数,每实例化一个对象,就会自动加1. `package ...
  • 变量可以被static 修饰,意义有发生变化吗? 下面我们举个栗子来说明: (1)变量static 修饰 #include <stdio.h> void test() { int num = 0; num++; printf("%d ", num); } int main() { int ...
  • static关键字
  • static关键字修饰

    2016-03-29 11:08:10
    ... ...Java里面static一般用来修饰成员变量或函数。但有一种特殊用法是用static 修饰内部类,普通类是允许...被static修饰的内部类可以直接作为一个普通类来使用,而需实例一个外部类(见如下代码)
  • 静态变量: 使用static关键字定义的变量。static可以修饰变量和方法,也有static静态代码块。static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它依赖类特定的实例,类的所有实例共享。只要这个...
  • static修饰的函数叫做静态函数,静态函数有两种,根据其出现的地方来分类: **如果这个静态函数出现在类里,那么它是一个静态成员函数;** 静态成员函数的作用在于:调用这个函数不会访问或者修改任何对象(非...
  • [Android]【安卓】【Java】用static关键字修饰类(只适用于内部类) 本篇博客已收录到我的安卓开发小结中——点击【安卓开发小结】 参考资料:用static关键字修饰类(只适用于内部类) Java里面static一般用来...
  • 1.static 静态的,可用来修饰属性,方法,*代码块,*内部类 static 修饰属性(类变量): 1.由类创造的所有对象,都共用这个属性。 2.当其中一个对象对此属性进行修改,会导致其他对象对此属性的一个调用。 实例...
  • Java里面static一般用来修饰成员变量或函数。...被static修饰的内部类可以直接作为一个普通类来使用,而需先实例一个外部类。public class OuterClass { public static class InnerClass { InnerClass(){
  • 1,静态成员函数的意义,在于信息共享,数据沟通,而在于管理静态数据成员, 完 成对静态数据成员的封装。 2,静态成员函数只能访问静态数据成员。原因:非静态成员函数,在调用时this 指 针当作参数传进。而静态成员...
  • JAVA中静态的东西都是属于类的,为类服务,构造函数是为了初始化对象,为对象服务。构造函数是用来生成实例,既然是实例就不是static的。这两者是相互矛盾的
  • static关键字

    2016-04-05 19:18:25
    2、 使用static关键字修饰一个方法:无需本类的对象就调用此方法 3、 使用static关键字修饰一个类 二、 static关键字内存结构分析三、 声明static方法的限制 1、 声明为static方法后仅能够调用其他的st
  • 深入理解static关键字

    万次阅读 多人点赞 2019-10-25 09:08:13
    提到static关键字,相信大家都陌生,这是相对比较难以理解的一个关键字,相信各位也都深深感受的到!本篇文章将好好总结一下static这个关键字。 文章目录1、static存在的主要意义2、static的独特之处3、静态...
  • abstract关键字、final关键字、static关键字、访问修饰符详解 abstract关键字: final关键字: static关键字: 访问修饰符: 转载于:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 238,072
精华内容 95,228
关键字:

哪个不能被static关键字修饰