社区
Java EE
帖子详情
最近看JAVA源代码Object类里面 hashCode() 方法前面有个native修饰符 大家平时开发写方法用native修饰符吗native啥意思啊
job920
2015-02-08 07:33:23
最近看JAVA源代码 Object类里面 hashCode() 方法前面有个native修饰符 大家平时开发写方法用native修饰符吗native啥意思啊
...全文
226
3
打赏
收藏
最近看JAVA源代码Object类里面 hashCode() 方法前面有个native修饰符 大家平时开发写方法用native修饰符吗native啥意思啊
最近看JAVA源代码 Object类里面 hashCode() 方法前面有个native修饰符 大家平时开发写方法用native修饰符吗native啥意思啊
复制链接
扫一扫
分享
转发到动态
举报
写回复
配置赞助广告
用AI写文章
3 条
回复
切换为时间正序
请发表友善的回复…
发表回复
打赏红包
mooonchen
2015-02-09
打赏
举报
回复
Java不是完美的,Java的不足除了体现在运行速度上要比传统的C++慢许多之外,Java无法直接访问到操作系统底层(如系统硬件等),为此Java使用native方法来扩展Java程序的功能。
http://soft.chinabyte.com/database/79/11333579.shtml
姜小白-
2015-02-08
打赏
举报
回复
调用本地方法,扩展java的跟平台交互的一些不足,像线程的启动,操作系统时间的获取等。 参考
认识理解Java中native方法
疯狂熊猫人
2015-02-08
打赏
举报
回复
native在java中是本地方法的意思。你可以理解为native方法实际调用的是C代码编写的方法。要开发native方法,需要编写C/C++这样的程序,将C/C++程序编译成dll文件,然后引入到java classpath中
【05-面向对象(下)】
基本数据
类
型的包装
类
•八大数据
类
型的包装
类
分别为: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 Print
Object
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); } } 复制代码 。。。。。。。。。。。。。。。。
【
java
进阶04:继承】
Object
类
需要重
写
的
方法
:toString()
方法
、equals()
方法
、finalize()
方法
以及
hashCode
()
方法
这个老祖宗
类
中的
方法
需要先研究一下,因为这些
方法
都是所有子
类
通用的。任何一个
类
默认继承
Object
,就算没有直接继承,最终也会间接继承。String
类
中SUN重
写
了他的toString
方法
和equals
方法
。使用IDEA自动生成toString和equals
方法
。String对象比较的时候必须使用equals
方法
。
Object
类
的 toString()
方法
。GC负责调用的finalize
方法
。
Object
类
的equals
方法
。equals()
方法
重
写
练习。
hashCode
()
方法
。
java
Object
类
源代码
详解 及nativ
Java
代码 package
java
.lang; public class
Object
{ /* 一个本地
方法
,具体是用C(C++)在DLL中实现的,然后通过JNI调用。*/ private static
native
void register
Native
s(); /* 对象初始化时自动调用此
方法
*/ static {
java
Object
类
源代码
详解 及
native
method.
java
Object
类
源代码
详解 及
native
method. package
java
.lang; public class
Object
{ /* 一个本地
方法
,具体是用C(C++)在DLL中实现的,然后通过JNI调用。*/ private static
native
void registerNat...
java
对象转
native
_
java
Object
类
源代码
详解 及
native
(转自 http://blog.csdn.net/sjw890821sjw/article/details/8058...
Java
代码package
java
.lang;publicclass
Object
{/*一个本地
方法
,具体是用C(C++)在DLL中实现的,然后通过JNI调用。*/privatestatic
native
voidregister
Native
s();/*对象初始化时自动调用此
方法
*/static{register
Native
s();}/*返回此
Object
的运行时
类
。*/p...
Java EE
67,512
社区成员
225,881
社区内容
发帖
与我相关
我的任务
Java EE
J2EE只是Java企业应用。我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。
复制链接
扫一扫
分享
社区描述
J2EE只是Java企业应用。我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章