java基础知识

最新推荐文章于 2022-05-28 18:17:04 发布

不带刺仙人球

最新推荐文章于 2022-05-28 18:17:04 发布

阅读量2.3k

点赞数

分类专栏： Java 文章标签：基础知识

本文链接：https://blog.csdn.net/zyzn1425077119/article/details/103442009

版权

Java 专栏收录该内容

101 篇文章 1 订阅

订阅专栏

1、abstract，可以修饰类、接口和方法；修改是类主要被继承；abstract修饰的类，其子类也是可以是abstract修饰的。

abstract不可以修饰变量。注意针对类和方法

2、线程

（1）一旦一个线程被创建，它就立即开始运行。（错误）应进入就绪队列，之后根据调度算法进行运行

（2）一个线程可能因为不同的原因停止并进入就绪状态。

（3）使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。

（4）当一个线程因为抢先机制而停止运行，它被放在可运行队列的前面。（错误）因为抢先机制而停止运行，说明该线程的优先级比较低，不可能排到可运行队列的前面。

3、C正确：

Intent主要用于同一个app中不同组件之间传递信息。不同app之间主要使用AIDL。

Service是一段长的生命周期，没有用户界面的程序，可以保持应用在后台运行，而不会因为切换页面而消失

android 中下列属于Intent的作用的是
A、实现应用程序间的数据共享
B、是一段长的生命周期，没有用户界面的程序，可以保持应用在后台运行，而不会因为切换页面而消失
C、可以实现界面间的切换，可以包含动作和动作数据，连接四大组件的纽带
D、处理一个应用程序整体性的工作 (范围太大)

4、在实现DAO设计模式时，下面哪种模式经常被采用： ( Factory模式)

A. Proxy模式

B. Factory模式

C. Prototype模式

D. Observer模式

5、原型模式可以利用一个对象,快速地生成一批对象。

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

6 HashSet的remove方法，如果存在该元素，则remove掉，并返回是否remove成功。

Set s=new HashSet();
        for(short i=0;i<100;i++ ){
        	s.add(i);   //i=0时，添加0，但下面remove的为-1，故每次都添加
        	s.remove(i-1);
        }
        System.out.print(s.size()); //100
        
		Set s1=new HashSet();
        s1.add("1");
        s1.add("2");
        boolean a1=  s1.remove("1");
        boolean a11=  s1.remove("4");
		System.out.println(a1+ "  "+s1+"  "+a11); //true  [2]  false


	}

7 super关键字

super关键字是在子类对象内部指代其父类对象的引用

super可以访问父类的成员变量，成员方法和构造方法

当子类总存在与父类中相同的属性和方法时，可以使用super来访问父类中的属性和方法
在子类构造方法中可以使用super调用父类的构造方法。
由于子类构造方法默认调用父类的无参构造方法，当父类没有无参构造方法时，可以使用super关键词来调用父类的有参构造方法。

关于sleep和wait,以下描述错误的是 (D)
A 、sleep是线程类的方法，wait是object的方法
B、sleep不释放对象锁，wait放弃对象锁
C、sleep暂停线程，但监控状态依然保持，结束后会自动恢复
D、wait进入等待锁定池，只有针对此对象发出notify方法获得对象锁进入运行状态

D中只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
注意是准备获取对象锁进入运行状态，而不是立即获得

一个线程可能因为不同的原因停止并进入就绪状态。

使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
当一个线程因为抢先机制而停止运行，它被放在可运行队列的前面。（错误）为抢先机制而停止运行，说明该线程的优先级比较低，不可能排到可运行队列的前面。

10 输出：fliton

package zhongxin;

import java.io.FileInputStream;

public class Ppvg {
	
	public int fliton(){
		try{
			FileInputStream din=new  FileInputStream("C:\\E\\check\\guize.txt");
			din.read();
		}catch(Exception e){
			e.printStackTrace();
			System.out.println("flywick");
			return 99;
		}finally{
			System.out.println("fliton");
			return 0;
		}
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Ppvg p=new Ppvg();
		p.fliton();
		
		
	}

}

11 2006年某人连续打工24天,共赚得190元（日工资10元,星期六半天工资5元,星期日休息无工资）.已知他打工是从1月下旬的某一天开始的,这个月的1日恰好是星期日,这人打工结束的那一天是2月（）日 A.2月6日 B.2月14日 C.2月18日 D.2月21日

选择C：每周工作5天半,工资55元, 190÷55=3（周）.25（元）,，则一共为3周+2工作日+1个周六，分数即4个周六+17个工作日+3个周日。

12 1)桌子上有4个杯子，每个杯子上写着一句话：第一个杯子：“所有的杯子中都有水果糖”；第二个杯子：“本标中有苹果”；第三个杯子：“本杯中没有巧克力”；第四个杯子：“有些杯子中没有水果糖”。如果其中只有一句真话，那么以下哪项为真?

A.所有的杯子中都有水果糖。

B.所有的杯子中都没有水果糖。

C.所有的杯子中都没有苹果。

D.第三个杯子中有巧克力。

E.第二个杯子中有苹果。

答案：D为真，只有一个杯子为真的话，第一个和第4个杯子有冲突，故这2个杯子中有一个为真。第2和第3位假，即第2个没有苹果，第3个有巧克力

13：链表具有的特点是()

不必事先估计存储空间
插入删除不需要移动元素
所需空间与线性表长度成正比

14： Mem类输出为0 1 2 3 4 5 。。。。。99

import java.util.Vector;

public class Mem {
	public static void main(String[] args) {
		Vector v=new Vector(10);
		for(int i=0;i<100;i++){
			Num o=new Num();
			o.setNum(i);
			v.add(o);
			o=null;
		}
		
		for(int i=0;i<100;i++){
			Num oo=(Num)v.get(i);
			oo.print();
		}
	}
}

Num类


class Num{
	int j=0;
	public void setNum(int x){
		this.j=x;
	}
	public void print(){
		System.out.print(this.j+"\n");
	}
	
}

15JSP有哪些内置对象?
1.page:JSP网页本身;
2.request:用户端请求，此请求会包含来自GET/POST请求的参数;
3.session:请求有关的会话;
4.application:将信息保存在服务器中，直到服务器关闭为止;
5.out:输出信息;
6.response:对请求进行响应;
7.pageContext:取得任何范围的参数;
8.config:取得服务器的配置信息;
9.exception:针对错误网页，显示异常信息;

以下关于Spring的说法是正确（）
对象的设计应使类和构件之间的耦合最小
在Spring配置文件中，就可以设置Bean初始化函数和消亡函数
延迟加载有2种方法：一是hibernate提供的延迟载入机制；二是Spring框架提供的DAO模式结合Hibernate延迟加载的Web方案。
使用Spring可以实现声明式事务
Spring中包含一个“依赖注入”模式的实现
Spring是一系列轻量级Java EE框架的集合
Spring并没有为我们提供日志系统，我们需要使用AOP（面向方面编程）的方式，借助Spring与日志系统log4j实现我们自己的日志系统。
Spring是一个轻量级的框架
非入侵式：Spring目标是一个非入侵式的服务框架。
Spring内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射，反射其实就是在运行时动态的去创建、
调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象和调用对象里的方法的

17 下面关于变量及其范围的陈述

class person{
    static String age;      //--类变量
    public String name="李四";    //--实例变量
}

实例变量是类的成员变量

局部变量在使用前必须被初始化

在方法中定义的局部变量在该方法被执行时创建（错误）原因为：在线程为该方法创建栈桢时被创建，而不是方法执行时创建

SessionID可以存储每个用户Session的代号，是一个不重复的长整型数字。
不同的用户窗口具有不同的session，即不同的用户，所以session不同
session可能超时间

19 关于Servlet Filter，下列说法正确的有（CD）。

A. Filter 其实就是一个Servlet

B. Filter 可以产生response

C. Filter可以在servlet被调用之前截获request

D. Filter可以用来处理统一认证，过滤不雅字句等。

说明：filter功能.它使用户可以改变一个 request和修改一个response. Filter 不是一个servlet,它不能产生一个response,它能够在一个request到达servlet之前预处理request,也可以在离开 servlet时处理response.换种说法,filter其实是一个”servlet chaining”(servlet 链).一个filter 包括:

20 3*0.1==0.3 此为false

System.out.println(3 * 0.1);

返回的结果是：0.30000000000000004。

0.1的二进制表示为无线循环

0.1转化成二进制的算法：

0.1*2=0.2======取出整数部分0

0.2*2=0.4======取出整数部分0

0.4*2=0.8======取出整数部分0

0.8*2=1.6======取出整数部分1

0.6*2=1.2======取出整数部分1
0.2*2=0.4======取出整数部分0
0.4*2=0.8======取出整数部分0
0.8*2=1.6======取出整数部分1
0.6*2=1.2======取出整数部分1

接下来会无限循环

0.2*2=0.4======取出整数部分0

0.4*2=0.8======取出整数部分0

0.8*2=1.6======取出整数部分1

0.6*2=1.2======取出整数部分1

所以0.1转化成二进制是：0.0 0011 0011 ......

21.

int x = 4;
System.out.println("value is " + ((x>4) ? 99.9 : 9));

返回为9.0

因若x>4为真则执行冒号前的，若x＞4为假，则执行冒号后的。因为整个表达式最高的是DOUBLE型，所以自动向上转型，显示9.0

99.9默认为double,最高

22. B 170

public class ListParamTest {
public static void resetList(List<Integer> dataList) {
dataList.subList(2,4).set(0,40); //此时为 [10, 20, 40, null]
dataList = new ArrayList<Integer>(dataList); //此时dataList值为[10, 20, 40, null]，此时由于为new了新对象
dataList.add(50); //[10, 20, 40, null,50] ***只是对新对象的修改，老对象仍然不变 [10, 20, 40, null]
}
public static void setOne(List<Integer> dataList) {
dataList.set(3,100);
}
public static void main(String[] args){
List<Integer> dataList = new ArrayList<Integer>(Arrays.asList(10,20,30,null));
resetList(dataList); //[10, 20, 40, null] 老对象不变
setOne(dataList); //[10, 20, 40, 100]
int sum = 0;
for(Integer v:dataList){
sum +=v;
}
System.out.println(sum);
}

```
160
```
```
170
```
```
抛出NullPointerException异常
```

抛出ArrayIndexOutOfBoundsException异常

关键是这条代码的理解 dataList.subList(2,4).set(0,40);

上网找资料也没有找到这样子用的例子

subList一看就是找dataList中的下标2到4的部分但这个下标的部分包括2，不包括4，所以应该是下标2和3的位置

获得了这么一个部分后下一个是set(0,40) 一开始以为是把下标2和3的位置分别设置为0，40 但算出来最终答案是错的

后来找了一个set的意思又思考了一下 set的声明是

复制代码

set(int index, E element)

//index -- 替换索引的元素下标

//element -- 要被存储在指定位置的元素（即内容）

然后我觉得它想表达的意思是找出下标为2和3之后下标2在这一【子部分】中就成为了“下标0” 因此是把“下标0”中的30改成40

所以该行代码执行后dataList的元素内容为 10，20，40，null

由于dataList的声明为List<Integer> dataList = new ArrayList<Integer>(Arrays.asList(10,20,30,null));

而asList得到的数组是的没有add和remove方法的，因此在resetList方法中重新声明了dataList = new ArrayList<Integer>(dataList);

所以dataList才可以执行add的语句：dataList.add(50);

但是重新声明时候是new了一个新的对象，因此这里的add对原来的dataList所指向的对象是不会做任何改变的，而前面的set却不同，是对原来dataList所指向对象的修改，所以resetList方法执行完后原来dataList现在的数据情况为：10，20，40，null

再经过setOne方法后，dataList数据情况为：10，20，40，100

因此最后sum结果为170

23 一棵树共有n个节点的数，其中所有分支节点的度均为k，则该数中叶子节点的个数为

树的根部2113为一个节点，那么5261第2层就4102有k个节点，这k个节点1653依次又有回k个节点，那么第3层就答有k²个节点，第4层就有k³个节点，……
假设有m层，那么叶子节点数为第m层的节点数：k^(m-1)
所有的节点数为1+k+k²+k³+…+k^(m-1)=(1-k^m)/(1-k)=n
得到k^m=nk-n+1,
所以k^(m-1)=k^m/k=(nk-n+1)/k

24 对象作为参数传递问题

test(Obj para){

para.name=name;

para.id=id;

}

public static void main(String[] args) throws Exception {

A a=nulll;

A b=new A();

test(a);

System.out.println(a) ;//此时a还是为null; （因a指向了null，经方法后，形参para之后开辟新地址，a指向还是空。para有新值）

System.out.println(b) ;//此时a正常的赋值

}

不带刺仙人球

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java基础知识

1、abstract，可以修饰类、接口和方法；修改是类主要被继承；abstract修饰的类，其子类也是可以是abstract修饰的。abstract不可以修饰变量。注意针对类和方法2、线程（1）一旦一个线程被创建，它就立即开始运行。（错误）应进入就绪队列，之后根据调度算法进行运行（2）一个线程可能因为不同的原因停止并进入就绪状态。（3）使用start()方法可以使一个线程成...
复制链接

扫一扫