济南某公司面试题。感觉很好。随做以记录。

1，下面给出的变量定义中，不正确的是 C
A，int _a=123; B,static int i=100;
C,float f=3.4; D,public int 1=100,j=2,k;
(不能数字开头，自定义标识符必须以字母、下划线或美元符号开头，其他位可以是字母（可以写中文，但是不符合规范）、数字、下划线或美元符号（$）。
自定义标识符不能与java中的关键字和保留字（const goto）相同。float f = (float)3.4）
2,若有定义int x=13；则执行完语句X%=x/2；后，x的值是 A
A，1 B，13 C，6 D，8
3，下列语句序列执行后，m的值是

int a=10,b=3,m=5;
	if(a==b)
		m+=a;
	else
		m=++a*m;
	System.out.println(m);

（i++和++i是什么意思？_百度知道
答
都是i=i+1的意思，区别在于i++是i先不自加，在语句完后自加，++i先自加；列如a=1+i++；i本来为1的话，这里a=1+1；语句完后i才加1为2；
a=1+++i的话就先i=i+1；i=2.然后a=i+1，a=3）
4，下列语句执行后，k的值是C

a=a<<2 就可以写成 a<<=2

int i=10,j=18,k=30;
		System.out.println(i<<=1); 20
		switch(j-i){
		case 8:k++;
		case 9:k+=3;
		case 10:k<<=1;
		default:k/=j;
		}
		System.out.println(k);1

A，31 B，32 C，1 D，3

6.下列语句执行过后，b3的值是
equals:比较两个String对象的内容是否相同;
“==”:比较两个String对象的引用是否指向同一个对象;也就是堆内存地址一样。

		String str_1="ABC";
		String str_2= new String("ABC");
		String str_3= new String("ABC");
		boolean b1=str_1.equals(str_2),b2=str_2==str_3,b3;
		System.out.println(b1);true
		System.out.println(b2);false
		b3=!b1?b1:!b2;
		System.out.println(b3);true

7,重载和重写的区别？
重写必须发生在具有父子关系的两个类中，重写方法的返回类型和参数列表必须和父类一样
重载必须在一个类体中，拥有相同的方法名，必须不同的参数列表。
8，下列类定义中，不正确的是 C
A，class x{}
B,class x implements y1,y2{} 这样是可以的。
C,static class x implements y3{}
D,public class x extends y4{}
9，请写出该文件编译执行后的输出结果

public class Aclass {
	public Aclass(){
		System.out.println("A class");
	}
	public void doPrint(){
		System.out.println("printer in A class");
	}
}
public class Bclass extends Aclass{
	public Bclass(){
		System.out.println("B class");
	}
	public void doPrint(){
		System.out.println("printer in B class");
	}
}
public class Cclass extends Bclass{
	public Cclass(){
		System.out.println("C Class");
	}
	public static void main(String[]args){
		Aclass c = new Cclass();
		c.doPrint();
	}
}
======================================
A class
B class
C Class
printer in B class
父类有！！那就用！！都是自家人客气啥。

10，面向对象思想的三大核心内容
封装：
继承：
多态：

封装就是将对象的属性和行为特征包装到一个程序单元（即类）中，把实现细节隐藏起来，通过公用的方法来展现类对外提供的功能，提高了类的内聚性，降低了对象之间的耦合性。 
继承是对原有类的拓展，举例说明：我现在有一个Person类，但是我想要一个学生对象，他拥有Person类的所有属性和方法，此外他还有学号属性，及上课、写作业等一些方法，我可以创建一个Student类，但是我不想重复写Person类中已经有了的属性和方法，那么，此时我就可以用Student类继承Person类，Student类就拥有了Person类里的属性和方法了，我只需要在Student类里添加另外的新的属性和方法就可以了。Person类就成为父类，Student类就称为子类。父类和子类之间是一般和特殊的关系，子类是一种特殊的父类。此外，子类还可以通过重写来改变父类中的方法，重写可以改变方法的返回类型和访问权限，不能改变方法名称。 
多态是建立在继承的基础上的，是指子类类型的对象可以赋值给父类类型的引用变量，但运行时仍表现子类的行为特征。也就是说，同一种类型的对象执行同一个方法时可以表现出不同的行为特征。

13，请写一段简单的程序，说明工厂模式。


//细节:命名规则类，接口名称都得大写
interface Fruit {
    //接口中的 public abstract 都是多余的声明，eclipse是发现不了的。
    //若是有心人就换编辑器，intellij idea，
    void eat();
}
 
class Apple implements Fruit {
    public void eat() {
        System.out.println("Apple");
    }
}
 
class Orange implements Fruit {
    public void eat() {
        System.out.println("Orange");
    }
}
 
// 构造工厂类  
// 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了  
class Factory {
    public static Fruit getInstance(String fruitName) {
        Fruit f = null;
        if ("Apple".equals(fruitName)) {//这么写是为了避免null.equal(),空指针异常，有人会问这个为什么吗？  
            f = new Apple();
        }
        if ("Orange".equals(fruitName)) {
            f = new Orange();
        }
        return f;
    }
}
 
class Hello {
    public static void main(String[] a) {
        Fruit f = Factory.getInstance("Orange");
        f.eat();
    }
}

14，请写一段单例模式代码

单件模式用途：
单件模式属于工厂模式的特例，只是它不需要输入参数并且始终返回同一对象的引用。
单件模式能够保证某一类型对象在系统中的唯一性，即某类在系统中只有一个实例。它的用途十分广泛，打个比方，我们开发了一个简单的留言板，用户的每一次留言都要将留言信息写入到数据库中，最直观的方法是没次写入都建立一个数据库的链接。这是个简单的方法，在不考虑并发的时候这也是个不错的选择。但实际上，一个网站是并发的，并且有可能是存在大量并发操作的。如果我们对每次写入都创建一个数据库连接，那么很容易的系统会出现瓶颈，系统的精力将会很多的放在维护链接上而非直接查询操作上。这显然是不可取的。
如果我们能够保证系统中自始至终只有唯一一个数据库连接对象，显然我们会节省很多内存开销和cpu利用率。这就是单件模式的用途。当然单件模式不仅仅只用于这样的情况。
下面对单件模式的懒汉式与饿汉式进行简单介绍：
下面对单件模式的懒汉式与饿汉式进行简单介绍：
1、饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。
2、懒汉式：当程序第一次访问单件模式实例时才进行创建。
如何选择：如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。

public Simple(){
     private static Single s=new Single();        
     private Single(){
     }  
     public static Simple getSimple(){
         return s;
     } 
}  
懒汉式~~~~~~~~很经典哦！
class Single1 {
    private static Single1 s = null;
    public Single1() {
    }
       //同步函数的demo
    public static synchronized Single1 getInstance() {
        if (s == null)
            s = new Single1();
        return s;
    }
    //同步代码快的demo加锁，安全高效
    public static Single1 getInStanceBlock(){
        if(s==null)
            synchronized (Single1.class) {
                if(s==null)
                    s = new Single1();
            }
        return s;
    }

在这里插入图片描述

int method(int i){
if(i<=0){
return 0;
}else{
return i*i+ method(i-1)
}
}

18，部署在应用服务器上的web应用，存放jar包的目录名叫：
在这里插入图片描述
发布后的tomcat目录：

20，事务的四大属性：原子性，一致性，隔离性，持久性
22，数据库关系如下：

Student （SNo,SName,SSex,SClass）;
学生表：学号，学生姓名，性别，班级
Course (CNo,CName);
课程表：课程编号，课程名称
StudentCourse  SC(SNo,CNo,Score)
成绩表：学号，课程编号，成绩

a,查询选修“数据库原理” 并且成绩在90分以上的学生名单。

SELECT student.SNo,student.SName,student.SSex,student.SClass
FROM student,course,studentcourse
WHERE
studentcourse.SNo=student.SNo
and
studentcourse.CNo=course.CNo
and
course.CName='语文'
and
studentcourse.Score>90;

b，分班级统计出至少有一门不及格的人数。

select SClass 班级,count(sno) 不及格人数
from student s
where s.Sno in(select DISTINCT(SNo) from studentcourse SC where  SC.Score<60)
group by s.SClass

最终我还是写出来了。

济南某公司面试题。感觉很好。随做以记录。

猜你喜欢