概要
最近在求职找工作，从网上找了一些Java笔试题来做，很多都是基础题，其中包含了一些关键的知识点，如父子类执行顺序等问题。题目来源参考博客。
题目
1. 以指定编码输出字符串，如“utf-8”
代码实现如下：
package coding;
public class Coding {
public static void main(String agrs[])
{
String s = "hello你好";
try {
String name = new String(s.getBytes(),"utf-8");
System.out.println(name);
}catch(Exception e)
{
e.printStackTrace();
}
}
}
2.给定整型数组用冒泡法升序排序
代码实现如下：
package bubble;
public class Bubble {
public static void main(String agrs[])
{
int a[] = {3,1,2,6,7,8,9,5,4};
int temp = 0;
for(int i=0;i
{
for(int j=i+1;j
{
if(a[i]>a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
for(int i=0;i
{
System.out.println(a[i]);
}
}
}
3.求阶乘
这里采用递归求解，也可以通过循环求解。
代码实现如下：
package factorial;
public class Factorial {
public static int calculate(int n)
{
int factorial = 0;
if(n>1)
{
factorial = n*calculate(n-1);
}
else {
return 1;
}
return factorial;
}
public static void main(String agrs[])
{
System.out.println(calculate(6));
}
}
4.给定字母字符串按每个字母升序排序
代码实现如下：
package sort;
import java.util.Arrays;
public class Letter {
public static void main(String args[])
{
String s = "apple";
char c[] = s.toCharArray();
Arrays.sort(c);
for(char element : c)
{
System.out.println(element);
}
}
}
5.给定数字字符串按数字大小升序排序
代码实现如下：
package sort;
import java.util.Arrays;
public class Digital {
public static void main(String agrs[])
{
String s = "893158361";
char c[] = s.toCharArray();
Arrays.sort(c);
for(char element :c)
{
System.out.println(element);
}
}
}
6.给定一个整型数组输出只出现过一次的数
代码实现如下：
package unique;
public class Unique {
public static void main(String agrs[])
{
int a[] = {1,5,0,1,0,2,0,2,1,0};
int count =0;
for(int i=0;i
{
for(int j=0;j
{
if(a[i]==a[j])
{
count++;
}
}
if(count==1)
{
System.out.println(a[i]);
}
count=0;
}
}
}
7.实现一个单例模式
单例模式是常用设计模式中的一种
以下用两种方法实现单例模式
饥饿式单例
在类还没有初始化之前就已经产生类的实例了，所以是线程安全的。
实现代码如下：
package single;
public class HungrySingle {
/*
* 饥饿单例模式
*/
private static HungrySingle hungrySingle = new HungrySingle();
private HungrySingle()
{
}
public static HungrySingle getHungrySingle()
{
return hungrySingle;
}
public void say()
{
System.out.println("HungrySingle instance.");
}
}
双重检锁式单例
在使用时才创建单例对象，因为在创建时检查单例对象是否为null和使用了synchronize锁住类，确保单例以及线程安全。
实现代码如下：
package single;
public class DoubleCheckLockSingle {
/*
* 双重检锁单例模式
*/
public static DoubleCheckLockSingle doubleCheckLockSingle = null;
private DoubleCheckLockSingle()
{
}
public static DoubleCheckLockSingle getDoubleCheckSingle()
{
if(doubleCheckLockSingle==null)
{
synchronized(DoubleCheckLockSingle.class)
{
if(doubleCheckLockSingle==null)
{
doubleCheckLockSingle = new DoubleCheckLockSingle();
}
}
}
return doubleCheckLockSingle;
}
public void say()
{
System.out.println("DoubleCheckLockSingle instance.");
}
}
8.字符串变量
实现代码如下：
package stringVariable;
public class StringVariable {
public static void main(String args[])
{
String s = "123";
s = "abc";
System.out.println(s);
}
}
9.父子类基础问题
Java中继承问题一个常考的题目，其中包括父子类加载顺序问题和子类隐藏父类的成员变量方法以及子类覆盖父类的方法。
父子类加载顺序问题
先看父类代码：
package executeOrder;
public class Father {
private String name;
public Father()
{
System.out.println("父类的无参构造方法");
}
public Father(String name)
{
this.name = name;
System.out.println("父类的有参构造方法");
}
static {
System.out.println("父类的静态代码块");
}
{
System.out.println("父类的非静态代码块");
}
public String getName()
{
System.out.println("父类的普通方法");
return this.name;
}
public static void main(String args[])
{
System.out.println("父类的主程序");
Father father = new Father("Tom");
father.getName();
}
}
父类执行结果图
可以看到父类中加载顺序为：父类的静态代码块--父类主程序--父类的非静态代码块--父类的有参构造方法--父类的普通方法。
子类继承父类加载顺序
如果只是父类加载顺序并不是很复杂，但是如果通过子类中继承，子类中加载顺序就变得稍微有些复杂。
以下为子类代码：
package executeOrder;
public class Children extends Father{
private String name;
public Children()
{
System.out.println("子类的无参构造方法");
}
public Children(String name)
{
this.name = name;
System.out.println("子类的有参构造方法");
}
static {
System.out.println("子类的静态代码块");
}
{
System.out.println("子类的非静态代码块");
}
public String getName()
{
System.out.println("子类的普通方法");
return this.name;
}
public static void main(String agrs[])
{
System.out.println("子类的主程序");
Father father = new Father("Tom");
father.getName();
Children children = new Children("Gavin");
children.getName();
}
}
子类中执行结果图
子类中继承父类后执行顺序发生了一些变化，加载顺序可以分为三个部分，第一部分为：父类的静态代码--子类的静态代码块--子类主程序，在这部分只执行一次不管后面有多少实例 。第二部分new了一个父类实例，执行顺序为：父类的非静态代码块--父类的有参构造方法--父类的普通方法。第三部分new了一个子类实例，执行顺序为：父类的非静态代码块--父类的无参构造方法--子类的非静态代码块--子类的有参构造方法--子类的普通方法。
子类隐藏父类的成员变量，子类覆盖父类的方法
父类代码如下：
package inherit;
public class Father {
private String name ="爸爸";
int age = 39;
public void say()
{
System.out.println("I am father.");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
子类代码如下：
package inherit;
public class Children extends Father{
private String name;
int age = 16;
public void say()
{
System.out.println("I am children.");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
测试类代码：
package inherit;
public class Test {
public static void main(String agrs[])
{
Father father = new Father();
System.out.println("name is "+father.getName());
System.out.println("age is "+father.age);
father.say();
System.out.println("-------------------------------------");
Father son = new Children();
son.setName("儿子");
System.out.println("name is "+son.getName());
System.out.println("age is "+son.age);
son.say();
System.out.println("-------------------------------------");
Children daughter = new Children();
daughter.setName("女儿");
System.out.println("name is "+daughter.getName());
System.out.println("age is "+daughter.age);
daughter.say();
}
}
测试类执行结果图
通过执行结果可以看出，子类可以覆盖父类的同名方法，子类可以隐藏父类的同名成员变量，但是在子类转换为父类型时同名成员变量为父类的值。
相关概念如下：
隐藏 ：child隐藏了parent的变量和方法，那么，child不能访问parent被隐藏的变量或者方法，但是，讲B转换成A中，可以访问A被隐藏的变量或者方法。
覆盖 ：child覆盖了parent的变量或者方法，那么，child不能访问parent被覆盖的变量或者方法，将child转换成parent后同样不能访问parent被覆盖的变量或者方法。
隐藏和覆盖的规则
1.父类的实例变量和静态变量能被子类的同名变量隐藏
2.父类的静态方法被子类的同名静态方法隐藏
3.父类的实例方法被子类的同名实例方法覆盖
4.不能用子类的静态方法隐藏父类中同样标示(也就是返回值 名字 参数都一样)的实例方法
5.不能用子类的实例方法覆盖 父类中同样标示的静态方法
6.这点儿请注意，就是变量只会被隐藏 不会被覆盖 ，无论他是实例变量还是静态变量，而且子类的静态变量可以隐藏父类的实例变量，子类的实例变量可以隐藏父类的静态变量
小结
以上都是一些比较常见的基础题，对于大多数人来说没有太大的难度，其中包含了一些小知识，有兴趣的朋友可以拿来巩固一下基础，学习编程基础真的很重要。多多支持呀，谢谢大家！
878
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
