方法体内部私有变量

最新推荐文章于 2022-04-21 20:27:02 发布
最新推荐文章于 2022-04-21 20:27:02 发布
阅读量424 收藏
点赞数 1
分类专栏： Unity学习经验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/debussyezio/article/details/80510753
版权

这里写图片描述
大括号里面的内容相当于是在一个区域内，定义一个变量，只能在大括号里面用;相当于把里面的私有了.
,

丨饭饭饭丨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java经典编程源码基础例程300.zip
04-25
Java经典编程源码例程，可以做为你的学习设计参考。 第1章 Java语言概述 1 实例001 输出“Hello World” 2 实例002 输出控制台传递的参数 2 实例003 输出由“*”组成的三角形 3 实例004 输出符号表情 5 第2章 Eclipse开发工具 6 实例005 下载并运行Eclipse工具 7 实例006 为Eclipse安装中文包 8 实例007 使用Eclipse注释代码 10 实例008 使用Eclipse格式化代码 11 实例009 安装WindowBuilder插件 12 实例010 开发计算器界面 14 第3章 Java语言基础 15 实例011 输出错误信息与调试信息 16 实例012 从控制台接收输入字符 16 实例013 重定向输出流实现程序日志 17 实例014 自动类型转换与强制类型转换 19 实例015 加密可以这样简单（位运算） 20 实例016 用三元运算符判断奇数和偶数 21 实例017 不用乘法运算符实现2×16 22 实例018 实现两个变量的互换 （不借助第3个变量） 23 第4章 流程控制 25 实例019 判断某一年是否为闰年 26 实例020 验证登录信息的合法性 27 实例021 为新员工分配部门 28 实例022 用switch语句根据消费 金额计算折扣 29 实例023 判断用户输入月份的季节 31 实例024 使用while循环语句与自增 运算符循环遍历数组 33 实例025 使用for循环输出杨辉三角形 34 实例026 使用嵌套循环在控制台上 输出九九乘法表 35 实例027 使用while循环计算1+ 1/2!+1/3!…1/20！ 36 实例028 使用for循环输出空心的菱形 38 实例029 终止循环体 39 实例030 循环体的过滤器 41 第5章 数组及其常用操作 43 实例031 获取一维数组的最小值 44 实例032 将二维数组中的行列互换 45 实例033 利用数组随机抽取幸运观众 47 实例034 用数组设置JTable表格的 列名与列宽 49 实例035 使用按钮控件数组实现 计算器界面 51 实例036 通过复选框控件数组实现 添加多个复选框控件 52 实例037 使用选择排序法对数组排序 53 实例038 使用冒泡排序法对数组排序 55 实例039 使用快速排序法对数组排序 57 实例040 使用直接插入法对数组排序 59 实例041 使用sort()方法对数组排序 61 实例042 反转数组中元素的顺序 63 第6章 面向对象入门 65 实例043 自定义图书类 66 实例044 温度单位转换工具 67 实例045 成员变量的默认初始化值 68 实例046 单例模式的应用 69 实例047 汉诺塔问题求解 70 实例048 编写同名的方法 71 实例049 构造方法的应用 72 实例050 统计图书的销售量 73 实例051 两只完全相同的宠物 74 实例052 重新计算对象的哈希码 76 实例053 使用字符串输出对象 77 实例054 Java对象的假克隆 78 实例055 Java对象的浅克隆 80 实例056 Java对象的深克隆 82 实例057 序列化与对象克隆 84 实例058 深克隆效率的比较 87 第7章 面向对象进阶 89 实例059 经理与员工的差异 90 实例060 重写父类中的方法 92 实例061 计算几何图形的面积 93 实例062 简单的汽车销售商场 95 实例063 使用Comparable接口自定 义排序 96 实例064 策略模式的简单应用 98 实例065 适配器模式的简单应用 100 实例066 普通内部类的简单应用 102 实例067 局部内部类的简单应用 103 实例068 匿名内部类的简单应用 104 实例069 静态内部类的简单应用 105 实例070 实例化Class类的几种方式 107 实例071 查看类的声明 108 实例072 查看类的成员 110 实例073 查看内部类信息 112 实例074 动态设置类的私有域 113 实例075 动态调用类中方法 115 实例076 动态实例化类 116 实例077 创建长度可变的数组 117 实例078 利用反射重写toString()方法 119 第8章 字符串与包装类 121 实例079 将数字格式化为货币字符串 122 实例080 货币金额大写格式 123 实例081 String类格式化当前日期 125 实例082 字符串大小写转换 1
【05-面向对象(下)】
07-03
基本数据类型的包装类 •八大数据类型的包装类分别为：Byte、Short、Integer、Long、Character、 Float、Double、Boolean。 把基本数据类型变量包装类实例是通过对应包装类的构造器来实现的，不仅如此，8个包装类中除了 Character之外，还可以通过传入一个字符串参数来构建包装类对象。 •如果希望获得包装类对象中包装的基本类型变量，则可以使用包装类提供的XxxValue()实例方法。 自动装箱与自动拆箱 •JDk还提供了自动装箱和自动拆箱。自动装箱就是把一个基本类型的变量直接赋给对应的包装类变量，自动拆箱 则与之相反。 •包装类还可以实现基本类型变量和字符串之间的转换，除了Character之外的所有包装类都提供了一个 parseXxx(String s)静态方法。 •如果将基本类型转换为这符串，只需在后面加+ “”进行连接运算。 Java 7对包装类的增强 •Java 7为所有包装类增加一个新方法： compare(x , y)的方法。该方法用于比较两个包装类实例，当x>y， 返回大于0的数；当x==y，返回0；否则返回小于0的数。 对象的方法 •打印对象和toString方法：toString方法是系统将会输出该对象的“自我描述”信息，用以告诉外界对象具有的状 态信息。 •Object 类提供的toString方法总是返回该对象实现类的类名 + @ +hashCode值。 •==和equals比较运算符：==要求两个引用变量指向同一个对象才会返回true。equals方法则允许用户提供自 定义的相等规则。 •Object类提供的equals方法判断两个对象相等的标准与==完全相同。因此开发者通常需要重写equals方法。 类成员 •在java类里只能包含Field,方法,构造器,初始化块,内部类（接口、枚举）等5种成员。 用static修饰的类成员属 于类成员，类Field既可通过类来访问，也可以通过类的对象来访问。当通过对象来访问类属性时，系统会在底 层转换为通过该类来访问类 属性。 类成员规则 •类成员并不是属于实例，它是属于类本身的。只要类存在，类成员就存在。 •即使通过null对象来访问类成员，程序也不会引发NullPointerException。 　　类成员不能访问实例成员。 单例类 •如果一个类始终只能创建一个对象，称为单例类。须符合以下几个条件： 　　–1.我们把该类的构造器使用Private修饰，从而把该 类的所有构造器隐藏起来。 　　–2.则需要提供一个public方法作为该类的访问点，用于创建该类的对象，且必须使用static修饰 　　–3.该类还必须缓存已经创建的对象，必须用static修饰 final变量 •final修饰变量时，表示该变量一旦获得 初始值之后就不可被改变。 •final既可修饰成员变量，也可以修饰局部变量。 final修饰成员变量 •成员变量是随类的初始化或对象初始化而初始化的。final修饰的成员变量必须由程序员指定初始值。 •对于类属性而言，要么在静态初始化中初始化，要么在声明该属性时初始化。 •对于实例属性，要么在普通初始化块中指定初始值。要么在定义时、或构造器中指定初始值。 final修饰局部变量 •使用final修饰局部变量时既可以在定义时指定默认值，也可以不指定默认值。 •给局部变量赋初始值，只能一次，不能重复。 final修饰基本类型和引用类型 •当使用final修饰基本数据类型时，不能对其重新赋值，不能被改变。 •但对引用类型的变量而言，它仅仅保存的是一个引用，final只能保证他的地址不变，但不能保证对象，所以引用 类型完全可以改变他的对象。 可执行“宏替换”的final变量 •对一个final变量来说，不管它是类变量、实例变量，还是局部变量，只要该变量满足3个条件，这个final变量就 不再是一个变量，而是相当于一个直接量。 　　–使用final修饰符修饰； 　　–在定义该final变量时指定了初始值； 　　–该初始值可以在编译时就被确定下来。 final方法 •final方法 •final 修饰的方法不可以被重写。 •final 修饰的方法仅仅是不能重写，但它完全可以被重载。 •final 修饰的类不可以被继承 不可变的类 •不可变的类要满足以下几个条件： 　　–1.使用private和final修饰符来修饰该类的属性 　　–2.提供带参数的构造器，用于根据传入参数来初始化类里的属性 　　–3.仅为该类的属性提供getter方法，不要为该类的属性提供setter方法，因为普通方法无法修改final修饰的 属性 　　–4.如有必要，重写Object类中hashCode 和equals •缓存实例的不可变类：如果程序经常需要使用不可变类的实例，则可对实例进行缓存。 抽象方法和抽象类 •抽象方法和类都必须使用abstract来修饰，有抽象方法的类只能定义成抽象类，抽象里也可以没有抽象方法。 • 抽象类不能被实例化，可以通过其子类给他赋值，普通类里有的抽象里也有，定义抽象方法只需在普通方法上增 加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）全部去掉，并在方法后增加分号 即可。 抽象类的特征 •抽象类的特征：有得有失，得到了新能力，可以拥有抽象方法；失去了创建对象的能力。 抽象类的作用 •抽象类代表了一种未完成的类设计，它体现的是一种模板。 •抽象类与模板模式。 接口的概念 •接口定义的是多个类共同的行为规范，这些行为是与外部交流的通道，这就意味着接口里通常是定义一组公用的 方法。 •接口体现了规范与实现分离的设计。 接口的定义 •和类定义不同，定义接口不再用class关键字，而是使用interface关键字。语法如下： •[修饰符] interface接口名 extends 父接口1,父接口2 ... •{ • 零个到多个常量定义... • 零个到多个抽象方法定义... • 零个到多个内部类、接口、枚举定义... • 零个到多个默认方法或类方法定义... •} 接口里的成分 •在定义接口时，接口里可以包含成员变量（只能是常量），方法(只能是抽象实例方法、类方法或默认方法），内 部类（包括内部接口、枚举类 　　–常量都是：public static final修饰 　　–方法都是：public abstract 修饰 　　–内部的类：public static 接口的继承 •接口的继承和类继承不一样，接口完全支持多继承，子接口扩展某个父接口将会获得父接口的所有抽象方法，常 量属性，内部类和枚举类定义。 使用接口 •接口可以用于声明引用类型的变量，但接口不能用于创建实例。 •当使用接口来声明引用类型的变量时，这个引用类型的变量必须引用到其实现类的对象。 •一个类可以实现一个或多个接口，继承使用extends关键字，实现接口则使用implements关键字。 实现接口 •一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽 象方法）； •否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。 接口和抽象类的相似性 •接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。 •接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。 接口与抽象类的区别 •接口里只能包含抽象方法，不同包含已经提供实现的方法；抽象类则完全可以包含普通方法。 •接口里不能定义静态方法；抽象类里可以定义静态方法。 •接口里只能定义静态常量属性，不能定义普通属性；抽象类里则既可以定义普通属性，也可以定义静态常量属 性。 •接口不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而让其子类调用这些构 造器来完成属于抽象类的初始化操作。 •接口里不能包含初始化块，但抽象类则完全可以包含初始化块。 •一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补 Java单继承的不足。 面向接口编程 •接口体现了规范与实现分离的原则。充分利用接口可以很好地提高系统的可扩展性和可维护性。 •接口与简单工厂模式、命令模式等。 内部类 •我们把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类，有的也叫嵌套类，包含内 　　部类的类也被称为外部类有的也叫宿住类。 •内部类提供了更好的封装，内部类成员可以直接访问外部类的私有数据，因为内部类被当成其他外部类成员。 •匿名内部类适合用于创建那些仅需要一次使用的类。 非静态内部类 •定义内部类非常简单，只要把一个类放在另一个类内部定义即可。 •当在非静态内部类的方法内访问某个变量时，系统优先在该方法内查找是否存在该名字的局部变量，如果存在该 名字的局部变量，就使用该变量，如果不存在，则到该方法所在的内部类中查找是否存在该名字的属性，如果存在 则使用该属性。 •总之，第一步先找局部变量，第二步，内部类的属性，第三步。外部类的属性。 本文原创作者：pipi-changing 本文原创出处：http://www.cnblogs.com/pipi-changing/ 静态内部类 •如果用static修饰一个内部类，称为静态内部类。 •静态内部类可以包含静态成员，也可以包含非静态成员。所以静态内部类不能访问外部类的实例成员，只能访问 　　外部类的类成员。 •静态内部类的对象寄存在外部类里，非静态内部类的对象寄存在外部类实例里 使用内部类 •1.在外部类内部使用内部类－不要在外部类的静态成员中使用非静态内部类，因为静态成员不能访问非静态成 员。 • 2.在外部类以外使用非静态内部类。 　　–private 修饰的内部类只能在外部类内部使用。 　　–在外部类以外的地方使用内部类，内部类完整的类名应该OuterClass.InnerClass. 　　–在外部类以外的地方使用非静态内部类创建对象的语法如下：OuterInstance.new InnerConstructor() 　　–在外部类以外的地方使用静态内部类创建对象的语法如下：new OuterClass.InnerConstructer(); 局部内部类 •如果把一个内部类放在方法里定义，这就是局部内部类，仅仅在这个方法里有效。 •局部内部类不能在外部类以外的地方使用，那么局部内部类也不能使用访问控制符和static修饰 匿名内部类 •匿名内部类适合创建那种只需要一次使用的类，定义匿名内部类的语法格式如下： •new 父类构造器（实例列表) |实现接口） •{ • //匿名内部类的 类体部分 •} •匿名内部类不能是抽象类，匿名内部类不能定义构造器。 Lambda表达式入门 •Lambda表达式主要作用就是代替匿名内部类的繁琐语法。它由三部分组成： 　　–形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。 　　–箭头（->），必须通过英文等号和大于符号组成。 　　–代码块。如果代码块只有包含一条语句，Lambda表达式允许省略代码块的花括号，如果省略了代码块的花括 号，这条语句不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。 Lambda表达式需要返回值，而它的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回这条语句的 值。 Lambda表达式与函数式接口 •如果采用匿名内部类语法来创建函数式接口的实例，只要实现一个抽象方法即可，在这种情况下即可采用 Lambda表达式来创建对象，该表达式创建出来的对象的目标类型就是这个函数式接口。 •Lambda表达式有如下两个限制： 　　–Lambda表达式的目标类型必须是明确的函数式接口。 　　–Lambda表达式只能为函数式接口创建对象。Lambda表达式只能实现一个方法，因此它只能为只有一个抽 象方法的接口（函数式接口）创建对象。 •为了保证Lambda表达式的目标类型是一个明确的函数式接口，可以有如下三种常见方式： 　　–将Lambda表达式赋值给函数式接口类型的变量。 　　–将Lambda表达式作为函数式接口类型的参数传给某个方法。 　　–使用函数式接口对Lambda表达式进行强制类型转换。 方法引用与构造器引用 种类 示例 说明 对应的Lambda表达式 引用类方法 类名::类方法 函数式接口中被实现方法的全部参数传给该类方法作为参数。 (a,b,...) -> 类名.类方法(a,b, ...) 引用特定对象的实例方法 特定对象::实例方法 函数式接口中被实现方法的全部参数传给该方法作为参数。 (a,b, ...) -> 特定对象.实例方法(a,b, ...) 引用某类对象的实例方法 类名::实例方法 函数式接口中被实现方法的第一个参数作为调用者，后面的参数全部传给该方法作为参数。 (a,b, ...) ->a.实例方法(b, ...) 引用构造器 类名::new 函数式接口中被实现方法的全部参数传给该构造器作为参数。 (a,b, ...) ->new 类名(a,b, ...) Lambda表达式与匿名内部类 •Lambda表达式与匿名内部类存在如下相同点： 　　–Lambda表达式与匿名内部类一样，都可以直接访问“effectively final”的局部变量，以及外部类的成员变 量（包括实例变量和类变量）。 　　–Lambda表达式创建的对象与匿名内部类生成的对象一样， 都可以直接调用从接口继承得到的默认方法。 •Lambda表达式与匿名内部类主要存在如下区别： 　　–匿名内部类可以为任意接口创建实例——不管接口包含多少个抽象方法，只要匿名内部类实现所有的抽象方 法即可。但Lambda表达式只能为函数式接口创建实例。 　　–匿名内部类可以为抽象类、甚至普通类创建实例，但Lambda表达式只能为函数式接口创建实例。 　　–匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认方法；但Lambda表达式的代码块不允许调 用接口中定义的默认方法。 手动实现枚举类 •可以采用如下设计方式： 　　–通过private将构造器隐藏起来。 　　–把这个类的所有可能实例都使用public static final属性来保存。 　　–如果有必要，可以提供一些静态方法，允许其他程序根据特定参数来获取与之匹配实例。 JDK 5新增的枚举支持 •J2SE1.5新增了一个enum关键字，用以定义枚举类。正如前面看到，枚举类是一种特殊的类，它一样可以有自 己的方法和属性，可以实现一个或者多个接口，也可以定义自己的构造器。一个Java源文件中最多只能定义一个 public访问权限的枚举类，且该Java源文件也必须和该枚举类的类名相同。 枚举类 •枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是继承Object 类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang. Comparable两个接口。 •枚举类的构造器只能使用private访问控制符，如果省略了其构造器的访问控制符，则默认使用private修饰；如 果强制指定访问控制符，则只能指定private修饰符。 •枚举类的所有实例必须在枚举类中显式列出，否则这个枚举类将永远都不能产生实例。列出这些实例时系统会自 动添加public static final修饰，无需程序员显式添加。 •所有枚举类都提供了一个values方法，该方法可以很方便地遍历所有的枚举值。 枚举类的属性、方法和构造器 •枚举类也是一种类，只是它是一种比较特殊的类，因此它一样可以使用属性和方法。 •枚举类通常应该设计成不可变类，也就说它的属性值不应该允许改变，这样会更安全，而且代码更加简洁。为 此，我们应该将枚举类的属性都使用private final 修饰。 •一旦为枚举类显式定义了带参数的构造器，则列出枚举值时也必须对应地传入参数。 实现接口的枚举类 •枚举类也可以实现一个或多个接口。与普通类实现一个或多个接口完全一样，枚举类实现一个或多个接口时，也 需要实现该接口所包含的方法。 •如果需要每个枚举值在调用同一个方法时呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法，每个 枚举值提供不同的实现方式，从而让不同枚举值调用同一个方法时具有不同的行为方式。 包含抽象方法的枚举类 •可以在枚举类里定义一个抽象方法，然后把这个抽象方法交给各枚举值去实现即可。 •枚举类里定义抽象方法时无需显式使用abstract关键字将枚举类定义成抽象类，但因为枚举类需要显式创建枚举 值，而不是作为父类，所以定义每个枚举值时必须为抽象方法提供实现，否则将出现编译错误。 垃圾回收机制 •垃圾回收机制只负责回收堆内存中对象，不会回收任何任何物理资源（例如数据库连接，网络IO等资源）。 •程序无法精确控制垃圾回收的运行，垃圾回收会在合适时候进行垃圾回收。当对象永久性地失去引用后，系统就 会在合适时候回收它所占的内存。 •垃圾回收机制回收任何对象之前，总会先调用它的finalize方法，该方法可能使该对象重新复活（让一个引用变量 重新引用该对象），从而导致垃圾回收机制取消回收 对象在内存中的状态 •激活状态：当一个对象被创建后，有一个以上的引用变量引用它。则这个对象在程序中处于激活状态，程序可通 过引用变量来调用该对象的属性和方法。 •去活状态：如果程序中某个对象不再有任何引用变量引用它，它就进入了去活状态。在这个状态下，系统的垃圾 回收机制准备回收该对象所占用的内存，在回收该对象之前，系统会调用所有去活状态对象的finalize方法进行资 源清理，如果系统在调用finalize方法重新让一个引用变量引用该对象，则这个对象会再次变为激活状态；否则该 对象将进入死亡状态。 •死亡状态：当对象与所有引用变量的关联都被切断，且系统会调用所有对象的finalize方法依然没有使该对象变成 激活状态，那这个对象将永久性地失去引用，最后变成死亡状态。只有当一个对象处于死亡状态时，系统才会真正 回收该对象所占有的资源。 强制垃圾回收 •强制系统垃圾回收有如下两个方法： 　　–调用System类的gc()静态方法：System.gc() 　　–调用Runtime对象的gc()实例方法：Runtime.getRuntime().gc() finalize方法 •finalize方法有如下四个特点： 　　–永远不要主动调用某个对象的finalize方法，该方法应交给垃圾回收机制调用。 　　–finalize方法的何时被调用，是否被调用具有不确定性。不要把finalize方法当成一定会被执行的方法。 　　–当JVM执行去活对象的finalize方法时，可能使该对象，或系统中其他对象重新变成激活状态。 　　–当JVM执行finalize方法时出现了异常，垃圾回收机制不会报告异常，程序继续执行。 对象的软、弱和虚引用 •强引用（StrongReference） •软引用－软引用需要通过SoftReference类来实现，当一个对象只具有软引用时，它有可能被垃圾回收机制回 收。 •弱引用－弱引用通过WeakReference类实现，弱引用和软引用很像，但弱引用的引用级别更低。对于只有弱引 用的对象而言，当系统垃圾回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。 •虚引用－虚引用通过PhantomReference类实现，虚应用完全类似于没有引用。虚引用对对象本身没有太大影 响，对象甚至感觉不到虚引用的存在。 修饰符的适用范围 顶层类/接口 成员属性 方法 构造器 初始化块 成员内部类 局部成员 public √ √ √ √ √ protected √ √ √ √ 包访问控制符 √ √ √ √ ○ √ ○ private √ √ √ √ abstract √ √ √ final √ √ √ √ √ static √ √ √ √ strictfp √ √ √ synchronized √ native √ transient √ volatile √ 使用JAR文件的好处 •1.安全 •2.加快下载速度 •3.压缩 •4.包封装 •5.可移植性 jar命令详解 •-c 创建新文档，-t 列出存档内容的列表， -x 展开存档中的命名文件 •-u 更新已存在的存档，-v生成详细输出到标准输出上 •-f 指定存档文件名，-m 包含 来自标文件的标明信息 •-o 只存储方式：未用ZIP压缩格式 •-m 不产生所有项的清单文件，- I 为指定的jar文件产生索引信息 •-c 改变到指定的目录， 创建可执行的JAR包 •1.使用平台相关的编译器将整个应用编译成平台相关的可执行性文件 •2.为整个应用编辑一个批处理文件 关于JAR包的技巧 •相当于一个压缩文件。 •可使用WinRAR来压缩JAR包。 •也可使用WinRAR来查看JAR包。 现在贴出代码： AutoBoxingUnboxing Primitive2String UnsignedTest WrapperClassCompare EqualTest Person OverrideEqualsRight PrintObject StringCompareTest ToStringTest NullAccessStatic Singleton Address CacheImmutaleTest FinalErrorTest FinalLocalTest FinalLocalVariableTest FinalMethodTest FinalReferenceTest FinalReplaceTest FinalVariableTest ImmutableStringTest IntegerCacheTest Person Sub extends PrivateFinalMethodTest StringJoinTest CarSpeedMeter Circle extends Shape abstract class Shape SpeedMeter Triangle 复制代码 public class AddCommand implements Command { public void process(int[] target) { int sum = 0; for (int tmp : target) { sum += tmp; } System.out.println("数组元素的总和是:" + sum); } } **************************************************** public class BetterPrinter implements Output { private String[] printData = new String[MAX_CACHE_LINE * 2]; // 用以记录当前需打印的作业数 private int dataNum = 0; public void out() { // 只要还有作业，继续打印 while (dataNum > 0) { System.out.println("高速打印机正在打印：" + printData[0]); // 把作业队列整体前移一位，并将剩下的作业数减1 System.arraycopy(printData, 1, printData, 0, --dataNum); } } public void getData(String msg) { if (dataNum >= MAX_CACHE_LINE * 2) { System.out.println("输出队列已满，添加失败"); } else { // 把打印数据添加到队列里，已保存数据的数量加1。 printData[dataNum++] = msg; } } } ************************************************ public interface Command { // 接口里定义的process()方法用于封装“处理行为” void process(int[] target); } ********************************************** public class CommandTest { public static void main(String[] args) { ProcessArray pa = new ProcessArray(); int[] target = { 3, -4, 6, 4 }; // 第一次处理数组，具体处理行为取决于PrintCommand pa.process(target, new PrintCommand()); System.out.println("------------------"); // 第二次处理数组，具体处理行为取决于AddCommand pa.process(target, new AddCommand()); } } ************************************************* public class Computer { private Output out; public Computer(Output out) { this.out = out; } // 定义一个模拟获取字符串输入的方法 public void keyIn(String msg) { out.getData(msg); } // 定义一个模拟打印的方法 public void print() { out.out(); } } ********************************************** interface interfaceA { int PROP_A = 5; void testA(); } interface interfaceB { int PROP_B = 6; void testB(); } interface interfaceC extends interfaceA, interfaceB { int PROP_C = 7; void testC(); } public class InterfaceExtendsTest { public static void main(String[] args) { System.out.println(interfaceC.PROP_A); System.out.println(interfaceC.PROP_B); System.out.println(interfaceC.PROP_C); } } ************************************************** public interface Output { // 接口里定义的成员变量只能是常量 int MAX_CACHE_LINE = 50; // 接口里定义的普通方法只能是public的抽象方法 void out(); void getData(String msg); // 在接口中定义默认方法，需要使用default修饰 default void print(String... msgs) { for (String msg : msgs) { System.out.println(msg); } } // 在接口中定义默认方法，需要使用default修饰 default void test() { System.out.println("默认的test()方法"); } // 在接口中定义类方法，需要使用static修饰 static String staticTest() { return "接口里的类方法"; } } ********************************************** public class OutputFactory { public Output getOutput() { // return new Printer(); return new BetterPrinter(); } public static void main(String[] args) { OutputFactory of = new OutputFactory(); Computer c = new Computer(of.getOutput()); c.keyIn("轻量级Java EE企业应用实战"); c.keyIn("疯狂Java讲义"); c.print(); } } *********************************************** public class OutputFieldTest { public static void main(String[] args) { // 访问另一个包中的Output接口的MAX_CACHE_LINE System.out.println(lee.Output.MAX_CACHE_LINE); // 下面语句将引起"为final变量赋值"的编译异常 // lee.Output.MAX_CACHE_LINE = 20; // 使用接口来调用类方法 System.out.println(lee.Output.staticTest()); } } ************************************************ public class PrintCommand implements Command { public void process(int[] target) { for (int tmp : target) { System.out.println("迭代输出目标数组的元素:" + tmp); } } } *********************************************** // 定义一个Product接口 interface Product { int getProduceTime(); } // 让Printer类实现Output和Product接口 public class Printer implements Output, Product { private String[] printData = new String[MAX_CACHE_LINE]; // 用以记录当前需打印的作业数 private int dataNum = 0; public void out() { // 只要还有作业，继续打印 while (dataNum > 0) { System.out.println("打印机打印：" + printData[0]); // 把作业队列整体前移一位，并将剩下的作业数减1 System.arraycopy(printData, 1, printData, 0, --dataNum); } } public void getData(String msg) { if (dataNum >= MAX_CACHE_LINE) { System.out.println("输出队列已满，添加失败"); } else { // 把打印数据添加到队列里，已保存数据的数量加1。 printData[dataNum++] = msg; } } public int getProduceTime() { return 45; } public static void main(String[] args) { // 创建一个Printer对象，当成Output使用 Output o = new Printer(); o.getData("轻量级Java EE企业应用实战"); o.getData("疯狂Java讲义"); o.out(); o.getData("疯狂Android讲义"); o.getData("疯狂Ajax讲义"); o.out(); // 调用Output接口中定义的默认方法 o.print("孙悟空", "猪八戒", "白骨精"); o.test(); // 创建一个Printer对象，当成Product使用 Product p = new Printer(); System.out.println(p.getProduceTime()); // 所有接口类型的引用变量都可直接赋给Object类型的变量 Object obj = p; } } ************************************************* public class ProcessArray { public void process(int[] target, Command cmd) { cmd.process(target); } } 复制代码 。。。。。。。。。。。。。。。。
C#语言中的修饰符汇总
12-25
修饰符是用于限定类型以及类型成员的申明的一种符号。 下面主要从C#中的访问修饰符，作用于类和结构的修饰符，用在方法或变量的修饰符和特殊作用的修饰符四种，来给大家介绍。 1. 访问修饰符 指定声明的类型和类型成员的可访问性。 (1) public：是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。对访问公共成员没有限制。 (2) private：是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结 构体中才是可访问的。 (3) internal：是类型和类型成员的访问修饰符。只有在同一程序集的文件中，内部类型或成员才是可访问的。 (4) protected
Java学习笔记(必看经典)
01-31
JAVA的面向对象编程--------课堂笔记 面向对象主要针对面向过程。 面向过程的基本单元是函数。 什么是对象：EVERYTHING IS OBJECT（万物皆对象） 所有的事物都有两个方面： 有什么（属性）：用来描述对象。 能够做什么（方法）：告诉外界对象有那些功能。 后者以前者为基础。 大的对象的属性也可以是一个对象。 为什么要使用面向对象： 首先，面向对象符合人类看待事物的一般规律。 对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。 方法的定义非常重要。方法有参数，也可能有返回值。 注意区分：对象（本身）、对象的实现者、对象的调用者。 分析对象主要从方法开始。 我们通过类来看待对象，类是对象的抽象。 其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。 对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。这样才能使每个对象本身做成最好的。 对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。 实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。 可复用性是OOP的基础。 比较面向过程的思想和面向对象的思想： 面向过程的思想：由过程、步骤、函数组成，以过程为核心； 面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。 面向过程是先有算法，后有数据结构。 面向对象是先有数据结构，然后再有算法。 在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。 开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能 。 从语法上来看，一个类是一个新的数据类型。 在面向对象编程中，除了简单数据类型，就是对象类型。 定义类的格式： class Student{ 代码 } 注意类名中单词的首字母大写。 实例变量：定义在类中但在任何方法之外。（New出来的均有初值） 局部变量：定义在方法之中的变量。 局部变量要先赋值，再进行运算，而实例变量均已经赋初值。这是局部变量和实例变量的一大区别。 实例变量的对象赋值为null。 局部变量不允许范围内定义两个同名变量。实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。 实例变量和局部变量允许命名冲突。 书写方法的格式： 修饰符 返回值 方法名 调用过程中 方法体 可能出现的例外 public int/void addNumber(参数) throw Excepion {} 例： public int addNumber(int a,int b){ } 注：方法名中的参数int a,int b为局部变量 类方法中的一类特殊方法：构造方法。 构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。 注意：构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。 构造方法没有返回值。格式为：public 方法名。 构造方法的方法名与类名相同。 构造方法是在对象生成的过程中自动调用，不可能利用指令去调用。 在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。 用类来生成对象的语句： Student s=new Student()。 第一个Student表示这是用Student类进行定义。“Student()”表示调用一个无参数的构造方法。 如果()中有参数，则系统构造对象的过程中调用有参的方法。 此时S称为一个对象变量。 Student s的存储区域存放的是地址：一个对象在硬盘上占有一个连续地址，首地址赋予s空间。 S称为对象Student的引用。 注意：在对象变量中存放的是引用（地址）；在简单变量中存放的是数值。 可以构造多个构造方法，但多个构造方法的参数表一定不同，参数顺序不同即属于不同的构造方法： public student(string name,int a){ } public student(int a,string name){ } 为两个不同的构造方法。 如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。 练习：写一个类，定义一个对象，定义两个构造方法：一个有参，一个无参。 （编写一个程序验证对象的传递的值为地址） 注意下面这种形式： static void changename(student stu){stu.setName “LUCY”} 注意生成新的对象与旧对象指向无关，生成新对象生命消亡与旧对象无关。 面向对象方法的重载（overloading）和覆盖（overriding）。 在有些JAVA书籍中将overriding称为重载，overloading称为过载。 Overloading在一个类中可以定义多个同名方法，各个方法的参数表一定不同。但修饰词可能相同，返回值也可能相同。 在程序的编译过程中根据变量类型来找相应的方法。因此也有人认为 overloading是编译时的多态，以后我们还会学到运行时多态。 为什么会存在overloading技术呢？作为应对方法的细节。 利用类型的差异来影响对方法的调用。 吃（）可以分为吃肉，吃菜，吃药，在一个类中可以定义多个吃方法。 构造方法也可以实现overloading。例： public void teach(){}; public void teach(int a){}; public void teach(String a){}为三种不同的方法。 Overloading方法是从低向高转。 Byte—short—float—int—long—double。 在构造方法中，this表示本类的其他构造方法： student(){}; student(string n){ this();//表示调用student() } 如果调用student(int a)则为this(int a)。 特别注意：用this调用其他构造方法时，this必须为第一条语句，然后才是其他语句。 This表示当前对象。 Public void printNum(){ Int number=40； System.out.println(this.number); } 此时打印的是实例变量，而非局部变量，即定义在类中而非方法中的变量。 This.number表示实例变量。 谁调用this.number那么谁即为当前(this)对象的number方法。 封装：使对象的属性尽可能私有，对象的方法尽可能的公开。用private表示此成员属性为该类的私有属性。 Public表示该属性（方法）公开； Private表示该属性（方法）为只有本类内部可以访问（类内部可见）。 （想用private还要用set和get方法供其他方法调用，这样可以保证对属性的访问方式统一，并且便于维护访问权限以及属性数据合法性） 如果没有特殊情况，属性一定私有，方法该公开的公开。 如果不指明谁调用方法，则默认为this。 区分实例变量和局部变量时一定要写this。
为什么方法内部的私有变量不存在线程安全问题
huihuishou_su的博客
07-10 2825
    大家都知道，非线程安全问题存在于“实例变量”中，方法内部的私有变量，则不存在线程安全问题，这是为什么呢？     因为Java运行时数据区，虚拟机栈或者本地方法栈（执行方法所在的内存区域）是线程私有的，每个线程都有自己的虚拟机栈存储区和本地方法栈，所以线程在执行方法时，方法内部的变量不会牵扯到共享这一原则。只有共享内存才会牵扯到非线程安全问题，实例变量内存，在堆...
外部类访问内部类的私有变量（优秀回答）
weixin_40707866的博客
03-22 4568
内部类就相当于一个外部类的成员变量，所以可以直接访问外部变量，外部类不能直接访问内部类变量，必须通过创建内部类实例的方法访问。你想不通的肯定是指内部类的私有变量怎么可以被外部类访问吧，按常规，私有变量m只能在InnerClass里被访问，但你要注意，内部类就相当于一个外部类的成员变量，举个例子。class Outer{    private int m;    private class Inne...
为什么内部类的private变量可被外部类直接访问？
yygr的博客
04-21 1103
https://www.zhihu.com/question/54730071 问题: 我的意思是外部类通过内部类对象访问内部类私有变量，是怎么做到的？ 回答: 题主以后请直接把例子的代码以文本形式放到问题描述中。截图的话等于迫使别人再打一次字…虽然截图已经比手机拍照要好了orz 题主问的代码是像这样的： public class Outer { private int outProp = 8; class Inner { private int inP
java 方法变量_（个人笔记）java中的方法和变量
weixin_35802571的博客
02-15 1001
就我目前所学(未进阶) ，有错误或不规范求指出，谢谢！一、方法：java中的方法语法格式为：[修饰符列表] 返回值类型 方法名(形式参数列表){//方法体;}java中有三种方法：静态方法、构造方法、实例方法。1、静态方法语法：public static 放回值类型 方法名 (形参){//方法体;}调用静态方法：类名 . 方法名(实参);注意：静态方法顾名思义就是静态的，不用创建对象即可调用。当你...
Java外部类可以访问内部类private变量
weixin_30305735的博客
03-20 887
在讲Singleton时我举例时用过这样一段代码： public class SingletonDemo { private static class SingletonHolder{ private static SingletonDemo instance=new SingletonDemo(); } private SingletonDe...
PHP 面向对象技术(全面讲解).txt
04-21
的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程 序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。 LAMP 大讲堂PHP 面向对象技术（全面讲解） 网站：...
java方法体的变量内存分配
y909513070的博客
08-17 976
java方法体的变量作为返回值的原理 在读《代码大全》时看到，c语言在方法中不要返回局部变量的指针，想到了java中是可以返回任意类型，没有限制，这是怎么实现的。经过深入了解，c语言是可以返回局部变量指针，但是这个指针地址必须不是指向栈内存。java为什么可以返回任意类型，因为java控制了引用类型不允许在栈内存中创建，java在栈的内存分配上设定了栈只存放基本类型的变量数据和引用类型的引用
JS学习-内部（私有）函数
yohaome的博客
10-16 2561
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> </head> <body> <script type="text/javascr
私有内部类
BF-Lone Silver Wind 的博客
06-05 2603
私有内部类: 私有内部类中可以使用外部类中所有的内容,包括私有的 私有内部类只能在外部类中可以通过对象使用私有内部类中的私有内容,其他类中不能使用 //测试私有内部类 //参照private public class PrivateInTest { public static void main(String[] args) { //无法调用 其他类的私有内部类 Out out =...
局部变量在JVM的哪个区域
最新发布
08-15
### 回答1： 局部变量在JVM的栈内存中。栈内存用于存储方法中的局部变量、操作数栈、动态链接、方法出口等数据。每个线程都有自己的栈，每当一个方法被调用时，就会在栈上为该方法分配一个帧（Frame），该帧用于存储方法的局部变量和操作数栈等信息。当方法执行完毕后，该帧被弹出栈。因此，局部变量的生命周期与方法的生命周期一致，方法结束时局部变量也会被销毁。 ### 回答2： 局部变量在JVM中属于栈区（Stack）。在Java程序中，方法内部的局部变量会被存储在栈内存中。每当一个方法被调用时，JVM会为该方法创建一个栈帧（Stack Frame），栈帧中包含了局部变量的值以及其他与方法执行相关的信息。栈帧随着方法的调用而入栈，方法执行完毕后再出栈，局部变量也随之被销毁。由于栈区的生命周期短暂，所以局部变量的作用范围仅限于定义它的方法体内部。在栈区中，局部变量的存储空间是按照定义的顺序依次分配的，后定义的局部变量会被分配在较高的地址。而且，栈区的空间分配是自动进行的，不需要程序员手动管理。总之，局部变量在JVM的栈区中分配和存储，具有短暂的生命周期和自动管理的特点。 ### 回答3： 局部变量在JVM中存储在栈区（Stack Area）。 栈区是JVM内存中的一块区域，用于存储方法中的局部变量和方法调用的过程数据。每个线程在执行方法时，都会在栈区分配一块独立的空间，用于存储该线程的局部变量。 在方法被调用时，JVM会为该方法创建一个栈帧（Stack Frame），栈帧包含该方法的局部变量和其它相关信息。当方法执行完毕后，栈帧会被销毁，该方法的局部变量也会被释放。 局部变量的生命周期与方法的执行周期相关。当方法被调用时，局部变量会被分配内存空间，在方法执行完毕后会被销毁。局部变量的作用范围仅限于所在的方法内部，在方法外部是不可见的。由于栈区是线程私有的，因此每个线程都有自己独立的栈区，不同线程的栈区互不干扰。 栈区操作速度快，但是空间有限，容量随着JVM启动时设置的参数（如-Xss）而确定。当栈区空间不足时，会抛出StackOverflowError异常。因此，在编写代码时，应该合理地使用局部变量，避免方法深度过大或过多递归调用导致的栈溢出问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值