java游戏下载,需要学习哪方面

1、java游戏下载，需要学习哪方面？

这需要根据自己游戏的类型和要求加以选择。比如C++，java ,Erlang，go等等

Java目前作为游戏服务器开发语言已经很是普遍。但是大多数是作为页游或手游的服务器，而端游戏一般选择C++，因为端游对服务器的性能要求相对比较高一些。两种语言各有利弊。

Java的技术系统

需要学习的技术：

（1）Java基础知识

（2）JavaNIO编程

（3）Netty,Mina网络框架精通一种，其它作为了解。

（4）一种缓存框架：Redis；memcache熟悉使用一个。

（5）SQL语言，用于数据库：mysql

（6）springmvc主要用于http协议的服务器

（7）多线程编程，明白线程安全的重要性。

（8）Java并发集合的掌握。

（9）Linux常用的基本命令及shell脚本。

（10）数据库操作，比如mybatis。

2、有什么好玩的手机JAVA僵尸游戏？

屠村去玩生化危机4，屠城去玩僵尸世界大战，搞怪割草去玩丧尸围城，休闲去玩pvz 也可以弄个使命召唤玩僵尸模式 恶灵附身不知道算不算，反正吹爆一代 吹爆美国末日 生化危机2重置版做的挺好的 要恐怖的可以玩生7 其实生化危机系列都做的还行emmmm 就这样吧

3、玩手机上本来就有的JAVA游戏要钱么？

JAVA游戏有的要钱有的不要钱，看是什么软件了。 有的Java需要让你联网点击一个网页然后扣话费收费，有的Java需要你发短信然后扣话费。 你要实在觉得怕扣钱的话把SIM卡拔出来看它联不联网或者发不发短信，不发短信并且不联网的就不收费。联网收费的比较少，也不一定所有联网的Java都收费，但是让你发短信的Java游戏99%都收费。

4、学习java可以做游戏吗？

可以的，可以做Java游戏。

【资料】

主要是用Java分支中的J2ME来写，但是J2ME中需要Java的基础知识 。

现在有大部分人，都是从零开始学J2ME的，学习J2ME的时候，总是从Java基础开始学习，而且现在讲Java基础的书籍中都是以J2SE来讲基础，这就给学习造成了一些不必要的麻烦，下面将J2ME中用到的和不需要的Java基础知识做一个简单的说明。

J2ME中使用到的Java基础知识：

1、Java语法基础：包括基本数据类型、关键字、运算符等等

2、面向对象的思想：类和对象的概念，继承和多态等等。

3、异常处理

4、多线程

5、有什么网站可以有题让我练习呢？

如果是想找高质量面试题的话不妨看看动力节点官网上面试题也是非常全面新鲜的！

Java面试题及答案

1、String类可以被继承吗？

String类在声明时使用final关键字修饰，被final关键字修饰的类无法被继承。

接下来我们可以看一下String类的源代码片段：

public final class String implements java.io.Serializable, Comparable<String>,CharSequence { /** The value is used for character storage. */ private final char value[]; /** Cache the hash code for the string */ private int hash; // Default to 0 /** use serialVersionUID from JDK 1.0.2 for interoperability */ private static final long serialVersionUID = -6849794470754667710L;

● 为什么Java语言的开发者，把String类定义为final的呢？

因为只有当字符串是不可变的，字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间，因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的，那么String interning将不能实现，因为这样的话，如果变量改变了它的值，那么其它指向这个值的变量的值也会一起改变。如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。

因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。

因为字符串是不可变的，所以在它创建的时候HashCode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

● final关键字除了修饰类之外，还有哪些用法呢？

final修饰的变量，一旦赋值，不可重新赋值；

final修饰的方法无法被覆盖；

final修饰的实例变量，必须手动赋值，不能采用系统默认值；

final修饰的实例变量，一般和static联用，用来声明常量；

注意：final不能和abstract关键字联合使用。

总之，final表示最终的、不可变的。

2、& 和 && 的区别？

● &运算符是：逻辑与；&&运算符是：短路与。

● &和&&在程序中最终的运算结果是完全一致的，只不过&&存在短路现象，当&&运算符左边的表达式结果为false的时候，右边的表达式不执行，此时就发生了短路现象。如果是&运算符，那么不管左边的表达式是true还是false，右边表达式是一定会执行的。这就是他们俩的本质区别。

● 当然，&运算符还可以使用在二进制位运算上，例如按位与操作。

3、两个对象值相同equals结果为true，但却可有不同的 hashCode，这句话对不对？

不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希值（hashCode）应当相同。Java 对于equals方法和hashCode方法是这样规定的：

（1）如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；

（2）如果两个对象的 hashCode相同，它们并不一定相同。当然，你未必按照要求去做，但是如果你违背了上述原则就会发现在使用集合时，相同的对象可以出现在Set 集合中，同时增加新元素的效率会大大降低（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

关于equals和hashCode方法，很多Java程序员都知道，但很多人也就是仅仅了解而已，在Joshua Bloch的大作《Effective Java》（《Effective Java》在很多公司，是Java程序员必看书籍，如果你还没看过，那就赶紧去买一本吧）中是这样介绍 equals 方法的：

首先equals方法必须满足自反性（x.equals(x)必须返回true）、对称性（x.equals(y)返回true 时，y.equals(x)也必须返回true）、传递性（x.equals(y)和y.equals(z)都返回true时，x.equals(z)也必须返回true）和一致性（当x和y引用的对象信息没有被修改时，多次调用x.equals(y)应该得到同样的返回值），而且对于任何非null值的引用x，x.equals(null)必须返回false。实现高质量的equals方法的诀窍包括：

使用==操作符检查"参数是否为这个对象的引用"；

使用 instanceof操作符检查"参数是否为正确的类型"；

对于类中的关键属性，检查参数传入对象的属性是否与之相匹配；

编写完equals方法后，问自己它是否满足对称性、传递性、一致性；

重写equals时总是要重写hashCode；

不要将equals方法参数中的Object对象替换为其他的类型，在重写时不要忘掉@Override注解。

4、在 Java 中，如何跳出当前的多重嵌套循环？

在最外层循环前加一个标记如outfor，然后用break outfor;可以跳出多重循环。例如以下代码：

public class TestBreak {

public static void main(String[] args) {

outfor: for (int i = 0; i < 10; i++){

for (int j = 0; j < 10; j++){

if (j == 5){

break outfor;

}

System.out.println("j = " + j);

}

}

}

}

运行结果如下所示：

j = 0

j = 1

j = 2

j = 3

j = 4

5、重载（overload）和重写（override）的区别？重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载发生在一个类中，同名的方法如果有不同的参数列表（类型不同、个数不同、顺序不同）则视为重载。

重写发生在子类与父类之间，重写要求子类重写之后的方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。

● 方法重载的规则：

方法名一致，参数列表中参数的顺序，类型，个数不同。

重载与方法的返回值无关，存在于父类和子类，同类中。

可以抛出不同的异常，可以有不同修饰符。

● 方法重写的规则：

参数列表、方法名、返回值类型必须完全一致；

构造方法不能被重写；

声明为 final 的方法不能被重写；

声明为 static 的方法不存在重写（重写和多态联合才有意义）；

访问权限不能比父类更低；

重写之后的方法不能抛出更宽泛的异常；

6、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里是值传递还是引用传递?

是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的内存地址。这个值（内存地址）被传递后，同一个内存地址指向堆内存当中的同一个对象，所以通过哪个引用去操作这个对象，对象的属性都是改变的。

7、为什么方法不能根据返回类型来区分重载？

我们来看以下的代码：

public void testMethod(){

doSome();

}

public void doSome(){

}

public int doSome(){

return 1;

}

在Java语言中，调用一个方法，即使这个方法有返回值，我们也可以不接收这个返回值，例如以上两个方法doSome()，在testMethod()中调用的时候，Java编译器无法区分调用的具体是哪个方法。所以对于编译器来说，doSome()方法不是重载而是重复了，编译器报错。所以区分这两个方法不能依靠方法的返回值类型。

8、抽象类(abstract class)和接口(interface)有什么异同？

不同点：

● 抽象类中可以定义构造器，接口不能；

● 抽象类可以有抽象方法和具体方法，接口不能有具体方法；

● 接口中的成员全都是 public 的，抽象类中的成员可以使用private、public、protected、默认等修饰；

● 抽象类中可以定义成员变量，接口中只能是常量；

● 有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法；

● 抽象类中可以包含静态方法，接口中不能有静态方法；

● 一个类只能继承一个抽象类，一个类可以实现多个接口；

相同点：

● 不能够实例化；

● 可以将抽象类和接口类型作为引用类型；

● 一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类；

9、char 型变量中能不能存储一个中文汉字，为什么？

char 类型可以存储一个中文汉字，因为Java中使用的编码是Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个char 类型占2个字节（16 比特），所以放一个中文是没问题的。

补充：使用Unicode 意味着字符在JVM内部和外部有不同的表现形式，在JVM内部都是 Unicode，当这个字符被从JVM内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader和OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务。

10、抽象的(abstract)方法是否可同时是静态的(static)， 是否可同时是本地方法(native)，是否可同时被 synchronized？

都不能。

● 抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。

● 本地方法是由本地代码（如 C++ 代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。

● synchronized 和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

Java面向对象面试题

1、面向对象包括哪些特性，怎么理解的？

（1）封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。

（2）继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。

（3）多态：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当 A系统访问B系统提供的服务时，B 系统有多种提供服务的方式，但一切对 A 系统来说都是透明的。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：

第一：方法重写（子类继承父类并重写父类中已有的或抽象的方法）；

第二：对象造型（用父类型引用指向子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

（4）抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

2、访问权限修饰符 public、private、protected， 以及不写（默认）时的区别？

修饰符

当前类

同包

子类

其他包

public

√

√

√

√

protected

√

√

√

×

默认（缺省）

√

√

×

×

private

√

×

×

×

3、Java中为什么要用 clone？

在实际编程过程中，我们常常要遇到这种情况：有一个对象 A，在某一时刻 A 中已经包含了一些有效值，此时可能会需要一个和 A 完全相同新对象 B，并且此后对 B 任何改动都不会影响到 A 中的值，也就是说，A 与 B 是两个独立的对象，但 B 的初始值是由 A 对象确定的。在 Java 语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但clone()方法是其中最简单，也是最高效的手段。

● 说到对象的克隆，涉及到深克隆和浅克隆？

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

4、new一个对象的过程和clone一个对象的区别？

new 操作符的本意是分配内存。程序执行到 new 操作符时，首先去看 new 操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。

clone 在第一步是和 new 相似的，都是分配内存，调用 clone 方法时，分配的内存和原对象（即调用 clone 方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

5、Java中实现多态的机制是什么？

Java中的多态靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

6、谈谈你对多态的理解？

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源代码，就可以让引用变量绑定到各种不同的对象上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

7、谈谈你对面向对象的理解？

所谓对象就是由一组数据结构和处理它们的方法组成的，重点“数据”包括对象的特性、状态等的静态信息；“方法” 也就是行为，包括该对象的对数据的操作、功能等能动信息。把相同行为的对象归纳为类，类是一个抽象的概念，对象是类的具体。简单点说：对象就是类的实例。例如：小品演员就是一个类，赵本山就是一个对象。

面向对象的目的：解决软件系统的可扩展性，可维护性和可重用性。

● 面向对象的三大特性：封装、多态和继承：

（1）封装（对应可扩展性）：隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。封装是通过访问控制符（public protected private）来实现。一个类就可看成一个封装。

（2）继承（重用性和扩展性）：子类继承父类，可以继承父类的方法和属性。可以对父类方向进行覆盖（实现了多态）。但是继承破坏了封装，因为他是对子类开放的，修改父类会导致所有子类的改变，因此继承一定程度上又破坏了系统的可扩展性，只有明确的IS-A关系才能使用。继承要慎用，尽量优先使用组合。

（3）多态（可维护性和可扩展性）：接口的不同实现方式即为多态。接口是对行为的抽象，刚才在封装提到，找到变化部分并封装起来，但是封装起来后，怎么适应接下来的变化？这正是接口的作用，接口的主要目的是为不相关的类提供通用的处理服务，我们可以想象一下。比如鸟会飞，但是超人也会飞，通过飞这个接口，我们可以让鸟和超人，都实现这个接口。

面向对象编程（OOP）其实就是一种设计思想，在程序设计过程中把每一部分都尽量当成一个对象来考虑，以实现软件系统的可扩展性，可维护性和可重用性。

Java异常处理面试题

1、final、finally、finalize 的区别？

● final：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，被其修饰的类不可继承。

● finally：异常处理语句结构的一部分，表示总是执行。

● finalize：Object 类的一个方法，所以Java对象都有这个方法，当某Java对象没有更多的引用指向的时候，会被垃圾回收器回收，该对象被回收之前，由垃圾回收器来负责调用此方法，通常在该方法中进行回收前的准备工作。该方法更像是一个对象生命周期的临终方法，当该方法被系统调用则代表该对象即将“死亡”，但是需要注意的是，我们主动行为上去调用该方法并不会导致该对象“死亡”，这是一个被动的方法（其实就是回调方法），不需要我们调用。

2、Java中异常分为哪些种类？

按照异常需要处理的时机分为编译时异常(也叫受控异常)也叫 CheckedException 和运行时异常(也叫非受控异常)也叫 UnCheckedException。Java认为Checked异常都是可以被处理的异常，所以Java程序必须显式处理Checked异常。如果程序没有处理Checked 异常，该程序在编译时就会发生错误无法编译。这体现了Java 的设计哲学：没有完善错误处理的代码根本没有机会被执行。对Checked异常处理方法有两种：

● 第一种：当前方法知道如何处理该异常，则用try...catch块来处理该异常。

● 第二种：当前方法不知道如何处理，则在定义该方法时声明抛出该异常。

运行时异常只有当代码在运行时才发行的异常，编译的时候不需要try…catch。Runtime如除数是0和数组下标越界等，其产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。当然如果你有处理要求也可以显示捕获它们。

3、error和exception的区别？

Error类和Exception类的父类都是Throwable类，他们的区别如下：

● Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和预防，遇到这样的错误，建议让程序终止。

● Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

●Exception类又分为未检查异常（UnCheckedException）和受检查的异常(CheckedException)。运行时异常ArithmeticException，IllegalArgumentException编译能通过，但是一运行就终止了，程序不会处理运行时异常，出现这类异常，程序会终止。而受检查的异常，要么用 try…catch 捕获，要么用throws字句声明抛出，交给它的父类处理，否则编译不会通过。

4、调用下面的方法，得到的返回值是什么？

1. public int getNum() {

2. try {

3. int a = 1 / 0;

4. return 1;

5. } catch (Exception e) {

6. return 2;

7. } finally {

8. return 3;

9. }

10.}

代码走到第3行的时候遇到了一个MathException，这时第4行的代码就不会执行了，代码直接跳转到catch语句中，走到第 6 行的时候，异常机制有一个原则：如果在catch中遇到了return或者异常等能使该函数终止的话那么有finally就必须先执行完finally代码块里面的代码然后再返回值。因此代码又跳到第8行，可惜第8行是一个return语句，那么这个时候方法就结束了，因此第6行的返回结果就无法被真正返回。如果finally仅仅是处理了一个释放资源的操作，那么该道题最终返回的结果就是2。因此上面返回值是3。

5、Java 异常处理机制的理解？

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为 java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception。

Error表示应用程序本身无法克服和恢复的一种严重问题。

Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常。

系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组下标越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）。

普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

Java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。

6、说出最常见的5个RuntimeException？

● java.lang.NullPointerException 空指针异常；出现原因：调用了未经初始化的对象或者是不存在的对象。

● java.lang.ClassNotFoundException 指定的类找不到；出现原因：类的名称和路径加载错误；通常都是程序试图通过字符串来加载某个类时可能引发异常。

● java.lang.NumberFormatException 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符。

● java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生。

● java.lang.IllegalArgumentException 方法传递参数错误。

● java.lang.ClassCastException 数据类型转换异常。

● java.lang.NoClassDefFoundException 未找到类定义错误。

● SQLException SQL 异常，常见于操作数据库时的 SQL 语句错误。

● java.lang.InstantiationException 实例化异常。

● java.lang.NoSuchMethodException 方法不存在异常。

7、throw 和 throws 的区别？

● throw：

throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。

throw是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行throw一定是抛出了某种异常。

● throws：

throws语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。

throws主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。

● throws表示出现异常的一种可能性，并不一定会发生这种异常。