精华内容
下载资源
问答
  • 静态局部变量的生命期虽然为整个源程序,但是其作用域仍与自动变量相同。 静态局部变量的初始化是在编译时进行的。在定义时用常量或者常量表达式进行赋值。未赋值编译时系统自动赋值为0 静态局部变量具有可继承性。 ...

    static 全局区(静态区)什么时候释放?

    1. 静态局部变量在程序开始执行的时候就始终存在,也就是说它的生命期为整个源程序。
    2. 静态局部变量的生命期虽然为整个源程序,但是其作用域仍与自动变量相同。
    3. 静态局部变量的初始化是在编译时进行的。在定义时用常量或者常量表达式进行赋值。未赋值编译时系统自动赋值为0
    4. 静态局部变量具有可继承性。
    展开全文
  • 权限修饰符五、面向对象三大特征之二:继承性1.继承作用2.方法重写六、声明 一、static关键字 static,译为静态。 一个类成员包括:变量、方法、构造方法、代码块和内部类,static可以修饰除了构造方法外...

    一、static关键字

    static,译为静态。
    一个类的成员包括:变量、方法、构造方法、代码块和内部类,static可以修饰除了构造方法外的所有成员。
    使用static修饰的成员称为静态成员,是属于某个类的。而不使用static修饰的成员为实例成员,是属于该类的每个对象的。

    1 static变量

    static修饰的成员变量为静态变量,也叫类变量。类变量的声明周期和类相同,在整个应用程序执行期间都有效。

    静态变量的特点
    为该类的公用变量,属于类,被该类的所有实例共享,在类被载入时显示初始化。
    对于该类的所有对象来说,static成员变量只有一份,被该类所有对象共享。
    一般用“类名.类属性/方法”来调用。
    在static方法中不可直接访问非static的成员。

    静态变量和非静态变量的区别

    1. 份数不同:静态变量只有一份,为该类的所有实例对象共享。非静态变量每个实例对象都有一份。
    2. 存储的位置不同:静态变量存储在方法区(也叫元空间)内,非静态变量存储在堆内存中。
    3. 分配内存空间的时间不同:静态变量在类第一次被加载时分配空间,非静态变量在对象创建时分配空间。
    4. 生命周期不同:静态变量声明周期与类相等,非静态变量声明周期与所属对象相等。
    5. 调用方式不同:静态变量可以通过“类名.变量名”调用,也可以通过“对象名.变量名”调用。(推荐使用“类名.变量名”,因为静态变量只有一份,为所有该类创建的对象共享。)而非静态变量只能通过“对象名.变量名”调用。

    2 static方法

    static方法的作用
    访问static变量和static方法
    static方法的调用方式
    可以使用“类名.方法名()”调用,也可以使用“对象名.方法名()”调用。但是推荐使用第一种方式,因为static方法不依赖于对象,所以调用时可能并没有创建对象。
    不可以
    静态方法不可以访问非静态变量
    静态方法不可以访问非静态方法
    静态方法不可以使用this关键字

    个人理解:因为在静态方法不依赖于对象,所以调用静态方法时也许并没有创建对象,非静态变量和方法没有被分配空间,更没有this被创建。

    可以
    非静态方法可以访问静态变量
    非静态方法可以访问静态方法

    个人理解:在调用非静态方法时,必然已经创建对象,而静态变量和方法在创建对象前已经存在,所以可以访问

    3 static代码块

    代码块分为局部代码块,成员代码块和static代码块。

    3.1 局部代码块

    位置:方法中
    数量:多个
    执行顺序:依次执行
    局部代码块中定义的变量只作用与当前代码块

    3.2 成员代码块

    位置:类中
    数量:多个
    执行顺序:依次执行
    执行时间:每次创建对象时都会执行,先执行代码块再执行构造方法。
    作用:可以将各个构造方法中公共的代码提取到代码块中,实际开发中使用较少。
    匿名内部类不能提供构造方法,此时初始化操作放到代码块中

    3.3 static代码块

    位置:类中
    数量:多个
    执行顺序:依次执行
    执行时间:类被加载时执行,只执行一次。
    作用: 给静态变量赋予初始值。实际开发中应用较多,一般用于执行一些全局性初始化操作,例如创建工厂,加载数据库初始信息。

    二、package包

    包机制是Java中管理类的重要手段。开发中,我们会遇到大量同名的类,通过包可以很容易饿解决类重名的问题。另外,包还和访问权限有着密切的关系。

    1.如何定义包

    1. 包名一律小写。
    2. 包名:域名倒着写即可,再加上模块名,便于内部管理类。
    3. 看起来是包含关系的包实际上是两个完全独立的包,只是逻辑上是包含的关系。例如com.gao和com.gao.car

    另外如何优雅的给包命名呢???
    在这里插入图片描述
    知乎原网址:如何优雅的给个人项目的包命名

    三、import导入

    1. 默认是当前包下的类和接口
    2. Java会默认导入java.lang包下的所有类,所以我们可以直接使用。
    3. 可以使用通配符,例如 import java.util.*
    4. 如果导入两个同名的类,只能用包名+类名来显示调用相关类:java.util.Date date = new java.util.Date();

    在JDK1.5以后添加了静态导入功能,作用是可以导入指定类的静态属性或静态方法,这样就可以直接使用静态属性和静态方法。例如:import java.lang.Math.PI;

    四、面向对象的三大特征之一:封装性

    封装(encapsulation)是面向对象三大特征之一。合理的封装让外部调用更加方便,同时,对于实现着来说也更加容易修正和改版代码。

    1.引入封装

    举个栗子:我要看电视,只需要按一下开关和换台就可以了。不必了解电视机内部的复杂结构。制造厂家为了方便我们使用电视,把复杂的内部细节都封装起来,之暴露给我们简单的接口。

    封装就是吧对象的属性和操作结合为一个独立的整体,并尽可能的隐藏对象的内部细节。

    程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉。低耦合是仅暴露少量的方法给外部使用,尽量方便外部调用。

    封装的优点

    • 提高代码安全性。
    • 提高代码复用性。
    • 高内聚:封装细节,便于修改内部代码,提高可维护性。
    • 低耦合:简化外部调用,便于调用者使用,便于拓展和写作。

    2.权限修饰符

    在这里插入图片描述

    1. private 只有自己类能够访问
    2. defaule 默认的权限修饰符,只有同一个包的类可以访问
    3. protected 可以被同一个包和其他包中的子类访问
    4. public 可以被该项目所有包的所有类访问

    类的成员处理

    • 一般使用private访问权限(高内聚)
    • 提供相应的set/get方法访问相关属性,这些方法通常是public修饰的,以提供对属性的赋值取值操作。(布尔类型变量的get方法以is开头)
    • 一些用于本类的辅助性方法用private修饰,希望其他类调用的用public修饰。

    类的处理

    • 类只能使用public和默认修饰

    五、面向对象的三大特征之二:继承性

    继承(inheritance)是面向对象编程三大特征之一,它让我们更加容易实现对已有类的拓展、更加容易实现对现实世界的建模。

    1.继承的作用

    继承让我们更加容易实现类的拓展。例如,我们定义了动物类,再定义狗类只需要拓展动物类即可。实现了代码的重用,不必重复造轮子。

    继承的要点

    1. 父类也称为超类、基类。子类也称为派生类等。
    2. Java中只有单继承。(多继承会使继承链过于复杂,系统难于维护)
    3. 子类继承父类,可以得到父类除了构造方法外的的全部属性和方法,但不一定可以直接访问,比如父类的私有属性和方法。
    4. 一个类如果没有使用extends继承父类,则它的父类是:java.lang.Object

    2.方法重写

    当父类的方法无法满足子类的需求时,子类可以通过方法重写来满足需求。

    方法重载和方法重写的区别
    方法重载和方法重写是面向对象中的两个重要概念,两个概念实际上并没有什么关联,但是因为两者都是关于方法的,比较容易引起混淆。我认为两者的区别可以从总体和细分两个方面说明。
    总体来说,最主要的区别就是两者解决的问题不同,也就是作用不同。
    方法重载英文为overload,使用的位置是在当前类中,作用是为类的一种行为提供多种实现方式并提高可读性。
    方法重写英文为override,使用的位置是在子类与父类之间,作用是当父类的方法无法满足子类需求时,通过方法重写来满足需求。
    细分来说,一个方法的声明从左到右分别为修饰符、返回值类型、方法名、参数列表、返回的异常类型等。
    方法重载与修饰符、返回值类型和返回的异常类型无关,但是方法名必须相同,参数列表必须不同。
    而方法重写的方法名和参数列表必须相同,修饰符权限必须大于或等于父类方法的修饰符,返回值类型和返回的异常类型必须小于或等于父类方法的返回值类型和返回的异常类型。
    我们常用的方法重载有:构造方法的重载,println()方法的重载。
    常用的方法重写有:Object类的toString()、equals()和hashCode()等都可被子类重写。
    另外,如果方法被final修饰或者为静态方法,则无法重写。

    六、声明

    文档来源于“北京尚学堂”,本人只进行了知识点的整理,目的在方便自己。
    另外如果有朋友想学习java、python、前端、大数据等知识欢迎来到“北京尚学堂”咨询

    北京尚学堂官网:北京尚学堂

    展开全文
  • 内部类 java中允许类内部单独定义一个类,那么每一个内部...2.不符合高内聚,低耦合设计思想,造成代码可维护差 语法 class Out{ //外部类的变量 //外部类方法 class In{ //内部类的变量 //内部类方法

    内部类
    java中允许类的内部单独定义的一个类,那么每一个内部类去实现和继承其它的类与接口,对外部类不是造成任何的影响;
    好处
    1.在内部类中可以访问外部类私有化变量
    2.每一个内部类去实现和继承其它的类与接口,对外部类不是造成任何的影响
    缺点
    1.造成代码冗余,不符合封装的思想
    2.不符合高内聚,低耦合的设计思想,造成代码可维护性差
    语法

    class Out{
        //外部类的变量
        //外部类的方法
        class  In{
        //内部类的变量
        //内部类的方法
        
    	}
    }
    

    注意
    1.java运行的最基本单位是类,c运行的基本单位是函数
    2.每一个内部类都会编译生成单独的字节码文件(Out$In.class)

    成员内部类
    内部类像外部类的成员属性和成员方法一样,内部类需要依赖于外部类对象
    语法

    class Out{
        //外部类的变量
        //外部类的方法
        class  In{
        //内部类的变量
        //内部类的方法
        
    }
    }
    

    注意
    1.成员内部类中不能定义静态的属性和方法
    2.成员内部类如何在方法中访问外部类的成员变量
    a.当成员内部类的属性名和外部类的成员属性名没有重名时,直接调用
    b:当成员内部类的属性名和外部类的成员属性名重名时
    调用成员内部类的成员变量使用this.a
    调用外部类的成员变量使用Out.this.a
    3.如何得到成员内部类的对象
    外部类名.内部类名 变量名=外部类对象.内部类对象
    成员内部类编译生成的字节码文件是Out$In.class

    package demo;
    
    import java.io.Serializable;
    
    /**
     * @author Eric 15665627080@163.com
     * @date 2019年8月8日
     * @time 上午9:16:15 package demo; public class Out{ } 类说明
     */
    public class Out {
    	 //外部类的成员变量
    	int a=10;
    
    	//外部类的成员方法
    	public void fun() {
    		System.out.println("外部类的成员方法"+a);
    	}
    	//外部类的成员内部类
    	class In {
    		//内部类的成员变量
    		int a=20;
    		int b;
    		//static int a;//如果允许?Out.In.a?
    		//内部类的成员方法
    		public void fun() {
    			int a=15;
    			System.out.println("内部类的局部变量"+a);
    			System.out.println("内部类的成员变量"+this.a);
    			System.out.println("外部类的成员变量:"+Out.this.a);
    			System.out.println("内部类的成员方法"+b);
    		}
    	}
    
    	
    }
    
    package demo;
    /**
     * @author Eric 15665627080@163.com
     * @date 2019年8月8日
     * @time 上午9:30:49
     * package demo;
     * public class Test{ }
     * 类说明	
     */
    public class Test {
    	public static void main(String[] args) {
    		//如何去调用内部类的成员方法?
    		
    		//1.得到外部类的对象
    		/*Out out=new Out();
    		
    		//2.得到内部类的内部对象
    		Out.In in=out.new In();*/
    		
    		//上述两步合并一下
    		Out.In in=new Out().new In();
    		in.fun();
    		
    	}
    
    }
    

    静态内部类
    使用static修饰的内部类,自动提升为普通类,相当于一个独立的类,和外部类级别相同,不依赖于外部类对象

    class Out{
        //外部类的变量
        //外部类的方法
       static class  In{
        //内部类的变量
        //内部类的方法
        
    }
    }
    

    注意
    1.静态内部类可以去定义静态属性和方法
    2.如何得到静态内部类对象
    In in=new In();
    3.单独使用静态内部类时,需要导包,格式是
    import demo1.Out.In;

    package demo1;
    
    import java.io.Serializable;
    
    /**
     * @author Eric 15665627080@163.com
     * @date 2019年8月8日
     * @time 上午9:16:15 package demo; public class Out{ } 类说明
     */
    public class Out {
    	 //外部类的成员变量
    	int a=10;
    
    	//外部类的成员方法
    	public void fun() {
    		System.out.println("外部类的成员方法"+a);
    	}
    	//外部类的静态内部类
    	static class In {
    		//内部类的成员变量
    		static int c=15;
    		int b;
    		//static int a;//如果允许?Out.In.a?
    		//内部类的成员方法
    		public void fun() {
    			
    			
    			System.out.println("静态内部类的成员方法"+b);
    		}
    	}
    
    	
    }
    
    
    
    package demo1;
    
    import demo1.Out.In;
    
    /**
     * @author Eric 15665627080@163.com
     * @date 2019年8月8日
     * @time 上午9:55:10
     * package demo1;
     * public class Test{ }
     * 类说明	
     */
    public class Test {
    	public static void main(String[] args) {
    		//静态内部类不依赖于外部类
    		Out.In in=new In();
    		in.fun();
    		System.out.println("打印静态内部类的静态属性"+In.c);
    	}
    
    }
    
    

    局部内部类
    在方法内声明局部内部类,它的使用范围不能脱离方法
    语法

    class Out{
        //外部类的变量
       public void 方法名(){
            class  In{
        		//内部类的变量
       			//内部类的方法
    			}}
    

    注意
    1.局部内部类的使用离不开方法,所有要想得到局部内部类对象必须在方法内调用
    2.局部内部类中如果想使用方法内的局部变量,那么该变量必须为final,形参也适用
    在JDK1.8之后,默认在形参和局部变量之前添加final关键

    package demo2;
    
    import java.io.Serializable;
    
    /**
     * @author Eric 15665627080@163.com
     * @date 2019年8月8日
     * @time 上午9:16:15 package demo; public class Out{ } 类说明
     */
    public class Out {
    	 //外部类的成员变量
    	int a=10;
    
    	//外部类的成员方法
    	public void fun( int d) {
    		final int b=5;//局部变量
    		System.out.println("外部类的成员方法");
    		
    		class In{
    			int c=15;
    			public void fun(){
    				//d=15;//报错,因为局部变量和形参前默认添加final关键字,不能二次赋值
    				//b=15;
    				System.out.println(b);
    				System.out.println("局部内部类的成员方法");
    			}
    		}
    		//访问局部内部类对象必须要在方法内访问
    		In in=new In();
    		in.fun();
    	}
    	
    	
    }
    
    
    
    package demo2;
    /**
     * @author Eric 15665627080@163.com
     * @date 2019年8月8日
     * @time 上午10:23:43
     * package demo2;
     * public class Test{ }
     * 类说明	
     */
    public class Test {
    	public static void main(String[] args) {
    		Out out=new Out();
    		out.fun(5);
    	}
    
    }
    

    匿名内部类
    对于一些不能new出来的类和接口,其new出来的就叫匿名内部类,安卓和中间件大量使用
    语法

    public interface Aa{
        //抽象方法
        
    }
    
    Aa aa=new Aa(){
    	//抽象方法的具体实现
    };
    

    注意
    1.匿名内部类的操作对象是接口和抽象类
    2.接口和抽象类中的抽象方法必须在匿名内部类中具体实现;
    3.如果在方法内部使用匿名内部类,如果匿名内部类中使用到了方法的形参和局部变量,那么该形参和局部变量必须要被final所修饰
    匿名内部类new出来的是接口,是为了减少代码冗余(少new一个实现接口的子类)
    在安卓中如果遇到一个方法的内部使用到了匿名内部类,那么匿名内部类中使用到的形参必须被final所修饰

    实战案例:
    写一个接口,有一个求正方形面积的方法,然后使用匿名内部类来调用方法

    public interface Area{
        public int square(int a);
    }
    
     public static void main(String[] args) {
            Area a = new Area() {
                @Override
                public int square(int a) {
                    return a*a;
                }
            };
            int square = a.square(5);
            System.out.println(square);
        }
    
    展开全文
  • 成员变量和局部变量的区别 static修饰成员后的作用 static作用总结 2.构造方法 构造方法的使用 this 3.匿名对象 4.注意点 5.静态代码块和构造代码块 封装 封装:(根据对属性的封装说明...

    昨天知识总结

    • 1.static
      • 成员变量和局部变量的区别
      • static修饰成员后的作用
      • static作用总结
    • 2.构造方法
      • 构造方法的使用
      • this
    • 3.匿名对象
    • 4.注意点
    • 5.静态代码块和构造代码块

    封装性

    • 封装性:(根据对属性的封装说明),把对成员变量的访问私有化,通过一个公共的方法间接的实现
    • 好处:提高了代码的安全性,可读性,复用性
    • 脏数据:在程序中出现的不合逻辑的数据
    • 原因:直接将数据交给了成员变量
    • 如何避免脏数据?
      • 1.不要将值赋值给成员变量----让成员变量不可见,将成员变量私有化
      • 2.通过方法间接的访问他,先过滤,后赋值
    • 因为对所有的属性都要进行赋值和取值,系统在制定了一套默认的规则 -----get set方法
      • set—完成赋值
        • 构成:修饰词 返回值 方法名(参数列表){方法体
          返回值
          }
        • 返回值:不需要返回值----这里写void
        • 方法名:set+对应成员变量的名字,成员变量的首字母大写
        • 参数列表:只有一个参数,参数的类型行与成员变量的类型一致,名字是成员变量的名字
        • 方法体:不需要返回值,我们可以写 this.成员变量 = 形参的名字
      • get—完成取值
        • 构成:修饰词 返回值 方法名(参数列表){方法体
          返回值
          }
        • 修饰词:一般是public
        • 返回值:类型与成员变量一致
        • 方法名:get+对应成员变量的名字,成员变量的首字母大写
        • 参数列表:不需要参数
        • 快捷键
        • shift+alt+s
    	public static void main(String[] args) {
    		//开枪射击
    		Gun gun = new Gun();
    		gun.setBulletNumber(-5);
    		gun.shoot();
    	}
    class Gun{
    	//属于修饰词,被他修饰的成员变量只能在当前类中可见
    	private  int bulletNumber;
    	private int age;
    	private int hight;
    	private int mode1;
    	private String name;
    	//添加子弹的方法
    //	public void addBullerNumber(int number) {
    //	}
    	public void setBulletNumber(int bulletNumber) {
    		
    		if(bulletNumber < 0) {
    			this.bulletNumber = 0;
    		}else {
    			this.bulletNumber = bulletNumber;		}
    	}
    	public int getBulletNumber() {
    		return bulletNumber;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public int getHight() {
    		return hight;
    	}
    	public void setHight(int hight) {
    		this.hight = hight;
    	}
    	public int getMode1() {
    		return mode1;
    	}
    	public void setMode1(int mode1) {
    		this.mode1 = mode1;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	//开枪射击
    	public void shoot() {
    		if(bulletNumber == 0) {
    			--bulletNumber;
    		}else{
    		System.out.println("剩余的子弹数量"+--bulletNumber);
    		}
    	}
    }
    

    类的关系–继承

    • extends:表示前面的继承后面的,如果一个类没有父类,默认继承Object在这里插入图片描述
    //创建他们的父亲
    //如果一个类里没有父类,默认值Object
    class Phone {
    	String color;
    	int model;
    	public void callPhone() {
    		System.out.println("打电话");
    		
    	}
    }
    //创建Hua类
    class Huawei extends Phone{
    //	String color;
    //	int model;
    	String niu;
    	public void callPhone() {
    		System.out.println("打电话");
    		
    	}
    }
    

    重写

    • 当子类有与父类同名(方法的所有位置都相同)的方法时,我们称为重写,
    • 注意点:子类的同名方法相当于把父类的覆盖了,父类的方法不会再被调用
    • 作用:在不改变父类方法名的前提下,实现父类现有功能的基础上,实现功能的扩充;
    • this:是一种引用数据类型,代表当前的对象,保存的是当前对象的地址
    • super:不是引用数据类型,可以代表父亲,通过super可以调用父类的方法
    • 注意点总结:
      • 1.私有方法不能被重写
      • 2.同名方法子类的权限大于等于父类的
      • 3.静态的方法只能覆盖静态的
    //创建他们的父亲
    //如果一个类里没有父类,默认值Object
    class Phone {
    	String color;
    	int model;
    	public void callPhone() {
    		System.out.println("打电话");
    		
    	}
    }
    //创建Iphonei类
    //  子类 extends 父类
    class Iphone extends Phone{
    //	String color;
    //	int model;
    	String gui;
    
    	public void fangShui() {
    		System.out.println("防水");
    	}
    	//重写父类的方法
    	public void callPhone() {
    		//System.out.println("打电话");
    		//this.callPhone();//这里会有优先找子类的同名方法,造成死循环
    		super.callPhone();//直接调到的是父类的方法
    		
    		//写自己的功能
    		System.out.println("写自己的功能");
    	}
    }
    

    继承使用构造方法

    • 1.当一个类只有一个带参数的构造方法,只能使用带参数的,不能使用无参的,如果想使用,必须手动建立无参构造方法
    • 2.创建构造方法的时候,如果我们不手动调用super(),系统会在自动调用父类无参构造方法
      • 原因:父类中也有成员变量需要进行初始化,而对象的成员变量只能由自己初始化所以必须调用super(),每个
      • 构造方法都会有默认的super()
    • 3.当父类中只有带参数的构造方法,子类的构造方法中就必须在第一行手动调用父类中带参数的构造方法super(参数)
      • 原因:因为在子类中有可能用到父类的成员变量,而成员变量在使用之前必须先进行初始化,否则不能使用
    • 总结:在继承体系之中,最好就是将父类的无参,有参构造方法都生成
    	public static void main(String[] args) {
    		Dog dog = new Dog();
    		dog.play();
    	}
    class Animal{
    	private String name;
    	public Animal(String name) {
    		super();
    		this.name = name;
    	}
    	public Animal() {
    		super();
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getName() {
    		return name;
    	}
    }
    
    
    
    class Dog extends Animal{
    	public Dog() {
    		super();//默认的代码,代表在调用父类空参的构造方法
    	}
    	public Dog(String name) {
    		//super代表的方法必须放在第一行
    		super(name);//代表调用父类有参构造方法
    		this.setName(name);
    	}
    	public void play() {
    		System.out.println("play");
    	}
    }
    

    单例设计模式

    • 设计模式:将前人总结好的经验我们直接拿来使用,
    • 一共有23种,常用的有单例设计模式,模板设计模式,工厂设计模式,装饰设计模式,适配器设计模式,代理设计模式,
    • 单例设计模式:一个类只有一个对象,建立一个全局访问点,将它提供出去大家使用
      • 1.用户只允许有一个对象
      • 2.单例类
      • 3.全局的访问点:得到的唯一的对象就是全局的访问点,怎么做到全局?-----static
      • 4.提供出去?
      • 5.供大家使用-----单例的功能,通过给单例类添加成员实现
    • 单例类的作用:
      • 1.可以实现两个对象之间的传值
      • 2.可以在全局范围内调用很多的功能。
      • 好处:可以让两个对象在完全没有关系的前提下,实现值得传递,降低了耦合性,提高了内聚性
    • 耦合性,内聚性在微观上说:描述的是类与类之间的关系
      • 好处:我们应该尽量提高内聚性,减少耦合性,可以提高程序的健壮性,增加代码的可移植性,方便实现模块儿化编程
    • 如何做到低耦合高内聚?
      • 在处理类鱼类的关系的时候,让类之间的关系越紧密耦合性越高,内聚性越低,反之,关系越松散耦合性越低,内聚性越高,

    饿汉式

    • 饿汉式:在定义变量的同时,完成赋值
    class SingleInstance{
    	//第二步:在单例类的内部创建当前类的对象,私有化,并变成静态的
    	private static SingleInstance singleInstance = new SingleInstance();
    	public int num; 
    	public static SingleInstance1 getInstance;
    	//第一步:将构造方法私有化
    	private SingleInstance() {
    		
    	}
    	//第三步:建立一个静态的公共的方法,将单例类对象提供出去
    	public  static SingleInstance getInstance() {
    		return singleInstance;
    	}
    	//功能区-----一般创建的是非静态的成员实现功能
    	//创建成员变量
    	//创建成员方法
    }
    

    懒汉式

    • 懒汉式:开始只是定义变量,什么时候使用,什么时候负责制造
    class SingleInstance1{
    	//第三步:在单例类的内部创建当前类的对象,私有化,并变成静态的
    	private static SingleInstance1 singleInstance = null;
    	//第一步:将构造方法私有化
    	private SingleInstance1() {
    		
    	}
    	//第三步:建立一个静态的公共的方法,将单例类对象提供出去
    	public  static SingleInstance1 getInstance() {
    		if(singleInstance == null) {//为了保证对象的唯一性
    			singleInstance = new SingleInstance1();
    			}
    		return singleInstance;
    	}
    

    修饰词final

    • final:最终的,不可改变的
    • 可以修饰的内容有
      • 类:final修饰的类不能有子类
      • 成员方法:final修饰的方法不能重写
      • 成员变量:被final修饰的变量必须先给一个值这个值不能被改变
      • 局部变量:被final修饰的变量是一个定值,不能被改变
    class Pig{
    	final String name = "bingbing";//被final修饰的变量必须先给一个值这个值不能被改变
    	public void play(int a) {
    		
    	}
    }
    class XiaoPig extends Pig {
    	public void play(int a) {
    		
    	}
    }
    
    展开全文
  • 静态类和静态类成员

    2010-09-14 16:40:00
    静态静态类必须直接从基类System.Object派生,这是因为从其他基类型派生类由于继承性仅适用于对象缘故而没有任何意义,而且不能创建静态实例。 静态类不能实现任何接口,这是因为只有使用类实例时才去...
  • 代码块 封装 继承

    2020-02-25 20:21:57
    语法:static{} 执行顺序:依次执行静态元素 自上向下 包括静态变量静态代码块 静态方法调用才执行 作用:经常给静态变量赋值 实际开发中还会把一些全局初始化配置放在静态代码块中执行 比如说一些准备工作 ...
  • 学习面向对象分析(OOA)与面向对象设计(OOD),在获取并列出概念类之后,必须要明确类与类之间关系。这些关系由弱到强大分为以下几种... 类A某个方法里使用了类B实例作为局部变量 类A调用了类B的静态方法 U...
  • 代码块,静态代码块

    2020-10-16 13:29:28
    作用:限定变量的生命周期,及早释放,以便提高内存利用率 构造代码块: 了解,偶尔使用 位置:类中方法外定义 特点:每次构造方法执行时,都会执行构造代码块中的代码,并且在构造方法第一行默认继承父类的构造...
  • final是个修饰符,它可以用来修饰类,类成员,以及局部变量。 final类是最终类,不能有子类,不可以被继承,但是可以继承其他类,且使用方式没有变化,可以正常创建对象,调用方法。 13-02 final修饰方法 ...
  • 1.代码块 分类:局部代码块、构造代码块、静态代码块、同步代码块。 ①局部代码块:在方法中出现;限定变量生命周期,及早释放,提高内存利用率 ②构造代码块:在类中方法外出现...(1)优点:①提高了代码复用 ...
  • 随手记_C++常考面试题

    2020-10-14 10:57:34
    在局部变量声明前加static表示这是一个“形似局部变量的静zhi态变量”。看起来dao和用起来像是局部变量,但实际上他的性质跟其他的静态变量是一样的,也就是说在内存中只有一个副本,不会像局部变量那样函数调用完毕...
  • 学习java第八天

    2020-10-18 15:34:44
    变量(除了局部变量): 静态变量 成员变量 方法 :静态方法 类名. 静态变量,非静态量区别 工具类编写 文档注释 不能嵌套 生成帮助文档:dos eclipse 在线文档 离线文档 继承 extends 单继承 不能多继承 多层继承...
  • 面试题

    2020-08-24 16:33:13
    静态局部变量:静态储存区 初始化默认为0 作用域(局部)结束 不会被释放 下次调用值不变 静态函数:默认extern,但只在声明他文件可见 类静态成员:实现类多个对象共享资源 类名::成员 (不是对象成员) 类静态函数...
  • Java中面向对象

    2021-01-15 20:04:41
    一、面向过程与面向对象 ...继承性: 封装性: 多态性: 九、访问权限修饰符 public: protected: default: private: 十、static,final,abstarct关键字 static: final: abstatct: 十一、抽象方法与抽象类
  • Java语言特性

    2021-05-23 19:26:09
    你在学JavaJava语言特性面向对象Java与C++区别Override(覆盖)与Overload(重载)封装,继承与多态编码小细节成员变量和局部变量静态方法和实例方法接口类和抽象类自动拆箱与装箱super()final关键字按值传递线程...
  • 背景:内部类出现是为了解决多继承的问题,因为内部类继承一个类并不影响外部类。 一、概念:在类内部... 局部内部类:就像方法里一个局部变量 1.成员内部类(实例) /** * 成员内部类 案例 */ public...
  • java中类关联

    2013-11-27 12:36:59
    1、 泛化(Generalization) 常说的继承。是说子类获得父类的功能的同时,还可以扩展自己的功能。 Java代码中表现为:extends 和 implements ...Java代码中的表现为局部变量,方法的参数,以及对静态方...
  • C++学习(33)

    2017-06-06 12:46:35
    (在同一个源文件中,外部变量与局部变量同名,则在局部变量的作用范围内,外部变量不起作用。) 2.动态绑定实现了方法的定义与具体的对象无关,而对方法的调用则可以关联于具体的对象。 面向对象有三种特性:...
  • 1)分类和分包思想 如学生管理系统 ...4)继承的成员方法区访问变量顺序 现在局部变量、再去成员范围找变量、最后去父类成员找变量 注意如果子类和父类有了一样成员变量 调用时采用就近原则 如果
  • 多态、抽象、接口

    2021-01-17 17:04:33
    变量的分类:局部变量;方法内部声明的变量、也可以是参数列表声明的对象; 静态变量;使用static修饰的变量; 成员变量;没有使用static修饰的变量; 多态相关的知识点: 软件设计六大原则; ①里氏替换原则:能够...
  • c++类之间基本关系

    2020-09-22 10:51:39
    类A某个方法里使用了类B实例作为局部变量 类A调用了类B的静态方法 2.关联 关联是一种弱所属关系,但并不是从属关系,类之间是平等。可以是双向关联, C++中,通过定义其他类指针类型成员来实现关联。 ...
  • java基础知识

    2018-08-06 17:03:00
    函数覆盖: 只有在继承时才有重写 private方法不可以被覆盖 ...内部类访问局部变量时,不能对局部变量重新赋值 抽象方法:在类中没有方法体方法,就是抽象方法。 抽象类:含有抽象方法类就叫抽象...
  • 【04-面向对象(上)】

    2018-07-03 21:41:30
    局部变量的运行机制 •局部变量仅在方法内有效。 •当方法执行完成时,局部变量便会自动销毁。 封装 •理解封装:封装是面向对象的三大特征之一。 • 封装包含两方面含义:  –合理隐藏。  –合理...
  • 2.4.4 内部类中的局部变量 2.5 小结 第3课 常见Java集合实现细节 3.1 Set和Map 3.1.1 Set和Map关系 3.1.2 HashMap和HashSet 3.1.3 TreeMap和TreeSet 3.2 Map和List 3.2.1 Mapvalues()方法 3.2.2 ...
  • 面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现...表现在代码层面,类A当中使用了类B,其中类B是作为类A方法参数、方法中的局部变量、或者静态方法调用。注意,要...
  • 在类处理多种对象类型地方使用继承和多态(进行中) 使用camelCase作为局部变量(进行中) 将类型定义重命名为.NET样式变体(正在进行) 支持外部地图纹理(正在进行) 调整网格例程以使用顶点和索引缓冲区...
  • 11.4.8 局部变量的修饰符 326 11.4.9 当final遇到引用类型成员变量 327 11.5 小结:修饰符作用大 328 11.6 习题 330 第12章 接口 331 教学视频:29分钟 12.1 自行车带来的问题 331 12.1.1 记录马路上的车辆 ...
  • final:最终 使修饰类,成员等具有最终属性(就没法改了)1....用final修饰词2.final特点1)可以修饰类,方法,变量(成员,局部静态) 2)final修饰类不能被继承举例final class Fu{ private void show1(){

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 410
精华内容 164
热门标签
关键字:

静态局部变量的继承性