锐客网

  1. 首页 > 生活百科 > it技术 > >

java魔法代码 java魔方代码

IT技术一个

求java大神帮我看看 小弟跪求 QAQ您好，这样：
Error occurred in script: 魔法时代.js
org.mozilla.javascript.WrappedException: Wrapped java.io.IOException: Prepare failed.: status=0x1 (魔法时代.js#1789)
at org.mozilla.javascript.Context.throwAsScriptRuntimeEx(Unknown Source)
at org.mozilla.javascript.MemberBox.invoke(Unknown Source)
at org.mozilla.javascript.NativeJavaMethod.call(Unknown Source)
at org.mozilla.javascript.Interpreter.interpretLoop(Unknown Source)
at script.attackHook(魔法时代.js:1789)
at org.mozilla.javascript.Interpreter.interpret(Unknown Source)
at org.mozilla.javascript.InterpretedFunction.call(Unknown Source)
at org.mozilla.javascript.ContextFactory.doTopCall(Unknown Source)
at org.mozilla.javascript.ScriptRuntime.doTopCall(Unknown Source)
at org.mozilla.javascript.InterpretedFunction.call(Unknown Source)
at net.zhuoweizhang.mcpelauncher.ScriptManager.callScriptMethod(ScriptManager.java:252)
at net.zhuoweizhang.mcpelauncher.ScriptManager.attackCallback(ScriptManager.java:319)
at dalvik.system.NativeStart.run(Native Method)
Caused by: java.io.IOException: Prepare failed.: status=0x1
at android.media.MediaPlayer.prepare(Native Method)
at java.lang.reflect.Method.invokeNative(Native Method)
at java.lang.reflect.Method.invoke(Method.java:511)
... 11 more
java初学者的程序java编程简单程序
要求：创建4个类
这4个类分别是
a、MessageInputer类，用来循环接收用户，并将接收的数据保存到Mytext.DF文件中 。
b、FillOpterator类，用来将数据写入文件，及数据从文件中读取 。
c、DBHandle类，用来负责数据库及获得数据库记录集 。
d、MessageCenter类 。
把上面四个类组起来，完成下面的功能：
程序给用户提供一输入信息界面（文本界面），程序将用户输入的信息保存到集合中 ，
当用户输入完毕后，程序将集合中的内容全部保存到Mytext.DF文件中.然后程序提示用户是
否将数据写入到数据库，如果选择是，则将数据从文件中读取，并将其保存到Access数据库 。
问题补充：急要原代码
急要原代码
急要原代码
急要原代码
急要原代码
提问者：lijugu - 助理 二级
答复 共 3 条
Java初学者需掌握的30个基本概念
基本概念
1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据 ， 很大限度上提高复用率 。
2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance) 。
3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field) 。
4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得 ， 根超类下文会做介绍 。
5.对象的3个主要特性
ehavior---说明这个对象能做什么 。
tate---当对象施加方法时对象的反映 。
dentity---与其他相似行为对象的区分标志 。
每个对象有唯一的indentity 而这3者之间相互影响 。
6.类之间的关系:
use-a :依赖关系
has-a :聚合关系
is-a :继承关系--例:A类继承了B类 ， 此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)
7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化 。
例:Data类的构造器叫Data
ew Data()---构造一个新对象，且初始化当前时间 。
Data happyday=new Data()---把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者
是不同的.new返回的值是一个引用 。
构造器特点:构造器可以有0个，一个或多个参数
构造器和类有相同的名字
一个类可以有多个构造器
构造器没有返回值
构造器总是和new运算符一起使用
8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法 。
9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包.java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内 。
10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段 。
11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类) 。
12.多态:在java中，对象变量是多态的.而java中不支持多重继承 。13.动态绑定:调用对象方法的机制 。
1）编译器检查对象声明的类型和方法名 。
2）编译器检查方法调用的参数类型 。
3）静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法 。
4）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本 。
5）动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码 。
14.final类:为防止他人从你的类上派生新类，此类是不可扩展的 。
15.动态调用比静态调用花费的时间要长 。
16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract 。
例: public abstract string getDescripition
17.Java中的每一个类都是从Object类扩展而来的 。
18.object类中的equal和toString方法 。
equal用于测试一个对象是否同另一个对象相等 。
toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示 。
(toString 方法是一个很重要的方法)
【java魔法代码 java魔方代码】19.通用编程:任何类类型的所有值都可以同object类性的变量来代替 。
20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小 。
21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类 。
22.class类为编写可动态操纵java代码的程序提供了强大的功能反射 ， 这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具 。
能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大 。
1）在运行时分析类的能力 。
2）在运行时探察类的对象 。
3）实现通用数组操纵代码 。
4）提供方法对象 。
而此机制主要针对是工具者而不是应用及程序 。
反射机制中的最重要的部分是允许你检查类的结构.用到的API有:
java.lang.reflect.Field 返回字段 。
java.reflect.Method 返回方法 。
java.lang.reflect.Constructor 返回参数 。
方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案 。
23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface 。
24.接口不是一个类，而是对符合接口要求的类的一套规范 。
若实现一个接口需要2个步骤:
1）声明类需要实现的指定接口 。
2）提供接口中的所有方法的定义 。
声明一个类实现一个接口需要使用implements 关键字
class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口 。
25.一个类只有一个超类，但一个类能实现多个接口 。Java中的一个重要接口：Cloneable
26.接口和回调.编程一个常用的模式是回调模式 ， 在这种模式中你可以指定当一个特定时间发生时回调对象上的方法 。
例:ActionListener 接口监听 。
类似的API有:
java.swing.JOptionPane
java.swing.Timer
java.awt.Tookit
27.对象clone:clone方法是object一个保护方法 ， 这意味着你的代码不能简单的调用它 。
28.内部类:一个内部类的定义是定义在另一个内部的类 。
原因是:
1）一个内部类的对象能够访问创建它的对象的实现，包括私有数据 。
2）对于同一个包中的其他类来说，内部类能够隐藏起来 。
3）匿名内部类可以很方便的定义回调 。
4）使用内部类可以非常方便的编写事件驱动程序 。
29.代理类(proxy):
1）指定接口要求所有代码
2）object类定义的所有的方法(toString equals)
30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型 。
回答者：ajian026 - 见习魔法师 二级 3-27 16:28
--------------------------------------------------------------------------------
Java初学者需掌握的30个基本概念
基本概念
1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的 ， 不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率 。
2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象 ， 即创建了这个类的一个实例(instance) 。
3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field) 。
4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍 。
5.对象的3个主要特性
ehavior---说明这个对象能做什么 。
tate---当对象施加方法时对象的反映 。
dentity---与其他相似行为对象的区分标志 。
每个对象有唯一的indentity 而这3者之间相互影响 。
6.类之间的关系:
use-a :依赖关系
has-a :聚合关系
is-a :继承关系--例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)
7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化 。
例:Data类的构造器叫Data
ew Data()---构造一个新对象，且初始化当前时间 。
Data happyday=new Data()---把一个对象赋值给一个变量happyday ， 从而使该对象能够多次使用 ， 此处要声明的使变量与对象变量二者
是不同的.new返回的值是一个引用 。
构造器特点:构造器可以有0个，一个或多个参数
构造器和类有相同的名字
一个类可以有多个构造器
构造器没有返回值
构造器总是和new运算符一起使用
8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法 。
9.包(package)Java允许把一个或多个类收集在一起成为一组 ， 称作包，以便于组织任务，标准Java库分为许多包.java.lang java.util java，net等 ， 包是分层次的所有的java包都在java和javax包层次内 。
10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段 。
11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类) 。
12.多态:在java中，对象变量是多态的.而java中不支持多重继承 。13.动态绑定:调用对象方法的机制 。
1）编译器检查对象声明的类型和方法名 。
2）编译器检查方法调用的参数类型 。
3）静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法 。
4）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本 。
5）动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码 。
14.final类:为防止他人从你的类上派生新类，此类是不可扩展的 。
15.动态调用比静态调用花费的时间要长 。
16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract 。
例: public abstract string getDescripition
17.Java中的每一个类都是从Object类扩展而来的 。
18.object类中的equal和toString方法 。
equal用于测试一个对象是否同另一个对象相等 。
toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示 。
(toString 方法是一个很重要的方法)
19.通用编程:任何类类型的所有值都可以同object类性的变量来代替 。
20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小 。
21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载 ， 虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类 。
22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具 。
能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大 。
1）在运行时分析类的能力 。
2）在运行时探察类的对象 。
3）实现通用数组操纵代码 。
4）提供方法对象 。
而此机制主要针对是工具者而不是应用及程序 。
反射机制中的最重要的部分是允许你检查类的结构.用到的API有:
java.lang.reflect.Field 返回字段 。
java.reflect.Method 返回方法 。
java.lang.reflect.Constructor 返回参数 。
方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案 。
23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface 。
24.接口不是一个类，而是对符合接口要求的类的一套规范 。
若实现一个接口需要2个步骤:
1）声明类需要实现的指定接口 。
2）提供接口中的所有方法的定义 。
声明一个类实现一个接口需要使用implements 关键字
class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口 。
25.一个类只有一个超类，但一个类能实现多个接口 。Java中的一个重要接口：Cloneable
26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法 。
例:ActionListener 接口监听 。
类似的API有:
java.swing.JOptionPane
java.swing.Timer
java.awt.Tookit
27.对象clone:clone方法是object一个保护方法 ， 这意味着你的代码不能简单的调用它 。
28.内部类:一个内部类的定义是定义在另一个内部的类 。
原因是:
1）一个内部类的对象能够访问创建它的对象的实现，包括私有数据 。
2）对于同一个包中的其他类来说，内部类能够隐藏起来 。
3）匿名内部类可以很方便的定义回调 。
4）使用内部类可以非常方便的编写事件驱动程序 。
29.代理类(proxy):
1）指定接口要求所有代码
2）object类定义的所有的方法(toString equals)
30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符 ， 布尔型
回答者：83071706 - 魔法学徒 一级 3-27 16:39
--------------------------------------------------------------------------------
数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型 ， 一种是字符型，被用于Unicode编码中的字符，布尔型
编写程序FooBizBaz.java，从1循环到50并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的/**
* 编写程序FooBizBaz.java，从1循环到150并在每行打印一个值
* 另外在每个3java魔法代码的倍数行上打印出“foo”,在每个5java魔法代码的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”
*/
public class FooBizBaz {
public static void main(String[] args) {
// 用于定义循环的数值，单独定义是为java魔法代码了不让代码中出现魔法值（及未经定义的常量）
int circulation = 150;
for (int i = 1; i = circulation; i) {
// 定义String变量用于字符串的拼接
String str = "";
// 将每一次循环的数值与定义好的str字符串拼接为新的字符串
str= i;
// 此处连续使用三个if是因为每一次判断都会执行一遍实现全部字符串拼接
// 如果使用else/ else if则只会执行其中一个满足条件的代码，导致后面代码不能完整拼接
if (i % 3 == 0){
str= " foo";
}
if (i % 5 == 0){
str= " biz";
}
if (i % 7 == 0) {
str= " baz";
}
// 此处统一输出 ， 如果选择在每一个if之后进行打印则不会输出以上三种if条件之外的数值
System.out.println(str);
}
}
}
java程序员敲代码的时候是怎么迅速打完public static void main(String args []);等类似代码的 。Ctrl 1 快速修复(最经典的快捷键,就不用多说java魔法代码了)
Ctrl D: 删除当前行
Ctrl Alt ↓ 复制当前行到下一行(复制增加)
Ctrl Alt ↑ 复制当前行到上一行(复制增加)
Alt ↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt ↑ 当前行和上面一行交互位置(同上)
Alt ← 前一个编辑的页面
Alt → 下一个编辑的页面(当然是针对上面那条来说了)
Alt Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift Ctrl Enter 在当前行插入空行(原理同上条)
Ctrl Q 定位到最后编辑的地方
Ctrl L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl M 最大化当前的Edit或View (再按则反之)
Ctrl / 注释当前行,再按则取消注释
Ctrl O 快速显示 OutLine
Ctrl T 快速显示当前类的继承结构
Ctrl W 关闭当前Editer
Ctrl K 参照选中的Word快速定位到下一个
Ctrl E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl /(小键盘) 折叠当前类中的所有代码
Ctrl ×(小键盘) 展开当前类中的所有代码
Ctrl Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt /来代替)
Ctrl Shift E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl J 正向增量查找(按下Ctrl J后,java魔法代码你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl Shift J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl Shift F4 关闭所有打开的Editer
Ctrl Shift X 把当前选中的文本全部变味小写
Ctrl Shift Y 把当前选中的文本全部变为小写
Ctrl Shift F 格式化当前代码
Ctrl Shift P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)
下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt Shift开头的了)
Alt Shift R 重命名 (是java魔法代码我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
Alt Shift M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
Alt Shift C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
Alt Shift L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
Alt Shift F 把Class中的local变量变为field变量 (比较实用的功能)
Alt Shift I 合并变量(可能这样说有点不妥Inline)
Alt Shift V 移动函数和变量(不怎么常用)
Alt Shift Z 重构的后悔药(Undo)
编辑
作用域 功能 快捷键
全局 查找并替换 Ctrl F
文本编辑器 查找上一个 Ctrl Shift K
文本编辑器 查找下一个 Ctrl K
全局 撤销 Ctrl Z
全局 复制 Ctrl C
全局 恢复上一个选择 Alt Shift ↓
全局 剪切 Ctrl X
全局 快速修正 Ctrl1 1
全局 内容辅助 Alt /
全局 全部选中 Ctrl A
全局 删除 Delete
全局 上下文信息 Alt ？
Alt Shift ?
Ctrl Shift Space
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt Shift ↑
Java编辑器 选择上一个元素 Alt Shift ←
Java编辑器 选择下一个元素 Alt Shift →
文本编辑器 增量查找 Ctrl J
文本编辑器 增量逆向查找 Ctrl Shift J
全局 粘贴 Ctrl V
全局 重做 Ctrl Y
查看
作用域 功能 快捷键
全局 放大 Ctrl =
全局 缩小 Ctrl -
窗口
作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl Shift W
全局 上一个编辑器 Ctrl Shift F6
全局 上一个视图 Ctrl Shift F7
全局 上一个透视图 Ctrl Shift F8
全局 下一个编辑器 Ctrl F6
全局 下一个视图 Ctrl F7
全局 下一个透视图 Ctrl F8
文本编辑器 显示标尺上下文菜单 Ctrl W
全局 显示视图菜单 Ctrl F10
全局 显示系统菜单 Alt -
导航
作用域 功能 快捷键
Java编辑器 打开结构 Ctrl F3
全局 打开类型 Ctrl Shift T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift F2
全局 打开资源 Ctrl Shift R
全局 后退历史记录 Alt ←
全局 前进历史记录 Alt →
全局 上一个 Ctrl ,
全局 下一个 Ctrl .
Java编辑器 显示大纲 Ctrl O
全局 在层次结构中打开类型 Ctrl Shift H
全局 转至匹配的括号 Ctrl Shift P
全局 转至上一个编辑位置 Ctrl Q
Java编辑器 转至上一个成员 Ctrl Shift ↑
Java编辑器 转至下一个成员 Ctrl Shift ↓
文本编辑器 转至行 Ctrl L
搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl Shift U
全局 打开搜索对话框 Ctrl H
全局 工作区中的声明 Ctrl G
全局 工作区中的引用 Ctrl Shift G
文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl ↑
文本编辑器 下滚行 Ctrl ↓
文件
作用域 功能 快捷键
全局 保存 Ctrl X
Ctrl S
全局 打印 Ctrl P
全局 关闭 Ctrl F4
全局 全部保存 Ctrl Shift S
全局 全部关闭 Ctrl Shift F4
全局 属性 Alt Enter
全局 新建 Ctrl N
项目
作用域 功能 快捷键
全局 全部构建 Ctrl B
源代码
作用域 功能 快捷键
Java编辑器 格式化 Ctrl Shift F
Java编辑器 取消注释 Ctrl \
Java编辑器 注释 Ctrl /
Java编辑器 添加导入 Ctrl Shift M
Java编辑器 组织导入 Ctrl Shift O
Java编辑器 使用try/catch块来包围 未设置java魔法代码，太常用了java魔法代码 ， 所以在这里列出,建议自己设置 。
也可以使用Ctrl 1自动修正 。
运行
作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift F5
全局 添加/去除断点 Ctrl Shift B
全局 显示 Ctrl D
全局 运行上次启动 Ctrl F11
全局 运行至行 Ctrl R
全局 执行 Ctrl U
java中如何定义常量1、java中使用final和static关键字定义常量 。首先打开编辑器 ， 编写代码 。当常量作为一个类的变量时 ， 一定要给它赋值，否则编译会失败的 。然后定义一个YEAR的常量，用来表示年，一年365天是固定的，这里习惯上大写，然后赋值为365：
3、static关键字是静态的意思，final前面说了是用来定义常量的 ， int是整型的，天数都是整天的 ， 所以用int型
4、最后用println函数打印两年的结果出来，都做完以后，进入编译：
5、运行后底部编译的结果就出来了，2年是730天 。以上就是java中常量的定义过程：
java魔法代码的介绍就聊到这里吧 ， 感谢你花时间阅读本站内容，更多关于java魔方代码、java魔法代码的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：jquery通过url传递是啥意思的简单介绍

    下一篇：苹果ios12扫描证件照，iphone扫描证件照