java基础

1.//静态方法在声明时已经分配给这个类，不能被子类覆盖。
public class Test
{

public static void main(String[] args) throws MalformedURLException
{
Parent p = new Parent();

Parent s = new student();

System.out.println(p.getName());//parent

System.out.println(s.getName());//parent
}

}

class Parent
{
public static String getName()
{
return "parent";
}
}

class student extends Parent
{
public static String getName()
{
return "student";
}
}

2.//关于值引用于对象引用
static String str = "1234";
public void vlueYiyong(String str)
{
str = "welcome";
}

public static void main(String[] args)
{

Test t = new Test();
t.vlueYiyong(str);//值的引用，输出结果为1234.值引用将一个值的副本传入到某个方法，修改的只是副本的值。
System.out.println(str);
A a = new A();
t.objectYiyong(a);//对象引用,输出结果为a
System.out.println(a.getStr());
}
public void objectYiyong(A a)
{
A b = new A();
b.setStr("b");
a.setStr("a");
a = b;//
}
}

class A
{
public String getStr()
{
return str;
}

public void setStr(String str)
{
this.str = str;
}

private String str;
}


3.public class Test2 {
static boolean foo(char c) {
System.out.print(c);//ABDCBDCB循环的执行顺序
return true;
}
public static void main(String[] argv) {
int i = 0;
for (foo('A'); foo('B') && (i < 2); foo('C')) {
i++;
foo('D');
}
}
}


4.class A {
protected int method1(int a, int b) { return 0; }
}
Which two are valid in a class that extends class A? (Choose two)
A. public int method1(int a, int b) { return 0; }
B. private int method1(int a, int b) { return 0; }
C. private int method1(int a, long b) { return 0; }
D. public short method1(int a, int b) { return 0; }
E. static protected int method1(int a, int b) { return 0; }
//总结：类的继承中，如果要想重载父类的方法，必须要和父类中的返回类型、可见性等等都要操作一致可见性可以扩展但不能缩小。AC

5.内部类的调用，以及匿名内部类实现接口。
eg1:public class Test1
{
public void someOutMethod()
{
new innerClass().inner();
}

class innerClass
{
public void inner()
{
System.out.println("这是内部类的方法");
}
}

public static void main(String[] args)
{
new Test1().new innerClass().inner();
}
}
//匿名内部类实现接口。
eg2:public IAnmous getAnmous()
{
return new IAnmous()
{
public void test()
{
System.out.println("这是一个匿名内部类实现了接口");
}
};
}
6.循环遍历map
for(java.util.Map.Entry<String, String> entry:map.entrySet())
{
System.out.println(entry.getKey());//输出map的键.
System.out.println(entry.getValue());//输出map的值。
}
7.关于数组转化的相关。
int[] a = { 1, 2, 3, 4 };
int[] b = { 5, 6, 7, 8, 9, 10 };
System.arraycopy(a, 0, b, 0, a.length);
//第一个参数是指源数据，第二个参数指复制的开始位置，第三个参数是指目标数据，第四个参数目标数组放置的起始位置0就是没指定，第五个参数是指复制的个数
for (int i : b)
{
System.out.println(i);
}
List<int[]> ary = Arrays.asList(a);//将字符串数组转化成list集合。
for (int[] c : ary)
{
for (int m : c)
{
System.out.println(m);
}
}
8.关于类的执行的顺序
Java类初始化顺序（无继承）：
静态变量-->静态初始化块-->其他变量-->初始化块-->构造器
Java类初始化顺序（有继承）：先静后动，先父后子
父类静态初始化---->子类静态初始化---->父类初始化块---->父类构造方法---->子类初始化块---->子类构造
eg:
public class Test3 extends Test4
{
{
System.out.println("1");

}
Test3()
{
System.out.println("2");
}
static
{
System.out.println("3");
}
{
System.out.println("4");
}
public static void main(String[] args)
{
new Test3();//6375142
}
}
class Test4
{
Test4()
{
System.out.println("5");
}
static
{
System.out.println("6");
}
{
System.out.println("7");
}
}


第一：淡淡final,finally,finalize的区别

final修饰符，如果一个类被声明为final，意味着它本能在派生出的新的子类，不能作为父类被继承。

eg:public static void main(String[] args) {
final String str="zhangsan";
System.out.println(str.substring(0));//zhangsan
}

finally再异常处理时候提供finally块来执行任何清楚操作，如果在抛出异常，那么相匹配的catch字句就会执行，然后控制就会进入。
eg:public class Mianshi1 {
public static void main(String[] args) {
parent.test(-1);//传入参数不正确 我是程序的finally块
}
}

class parent {
static void test(int num) {
try {
if (num < 0) {
System.out.println("传入参数不正确");
return;
} else {
System.out.println("传入的参数为：" + num);
}
} catch (Exception e) {
} finally {
System.out.println("我是程序的finally块");
}
}
}
finalize方法名，java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必须的清除工作，该方法是由垃圾回收器整理资源或者执行其他清理工作。finalize()方法是在垃圾回收器删除对象之前调用的。
eg:
public class Mianshi1 {
public static void main(String[] args) {
Book book = new Book(true);
book.checkin();//所有的Book对象在被当做垃圾回收之前都应该被签入。
//但在main()方法中，由于程序员的错误，有一本书为被签入。
//要是没有finalize()来验证终结条件，将很难发现这种缺陷
new Book(true);
System.gc();//用于强制进行终结动作。即使不这样做，通过重复的执行程序，最终也能找出错误的Book对象。
}
}
class Book {
boolean checkout = false;

Book(boolean checkout) {
this.checkout = checkout;
}

void checkin() {
checkout = false;
}

protected void finalize() {
if (checkout) {
System.out.println("Error:checkout");
}
}
}

第二：匿名类部类是否可以继承其他类，是否可以实现一个接口。
匿名的内部类是没有名字的内部类，不能继承其他类，但一个内部类可以作为一个接个内部类实现.
public class Mianshi1 {
public static void main(String[] args) {
AnonymousClass a=new AnonymousClass();
Ianonymous i=a.A();
i.test();

}
}
eg:
class AnonymousClass
{
public Ianonymous A()
{
// 这是个内部类实现了Ianonymous接口。
return new Ianonymous() {
public void test() {
System.out.println("这是匿名内部类实现了借口");
}
};
}
}
public interface Ianonymous {
public void test();
}

关于内部类:如果内部类中的类为静态类那么我们就不需要对外部类对象的引用。
public static void main(String[] args) {
outClass out=new outClass();
outClass.inerClass i=out.new inerClass();
i.inner();
//或者
new outClass().new inerClass().inner();// 可能如果写了这个代码可能要你写出所关联的相关代码
}
eg:class outClass
{
class inerClass
{
public void inner()
{
System.out.println("这是内部类的方法");
}
}
public void outer()
{
System.out.println("这是外部的方法");
}
}
关于静态内部类，是指内部类是静态的，不需要创建外部对象。2静态内部类不能引用外部的非静态的变量。
第三：HashMap与Hashtable的区别
1.HashMap与Hashtable都实现了Map接口，但是Hashtable继承的Dictionary而HashMap继承的是AbstactMap.
2.HashMap可以put为null的值，但是Hashtable不能put值为null
3.HashTable的线程安全性比HashMap强。

第四:Collections 与Collection的区别，其中四:Collections包含的基本方法。
Collection 是一个接口 包含了主要是集合的基本方法。add,addall,contains,remove,removeAll,size,toArray
/ \
Set List(ArrayList ,LinkdeList,Vector)
|
HashSet,linkHashSet,TreeSet

Colletions 是一个类包含了sort,reverse,allAll.
eg:
String [] num={"3","1","5","2","7","6"};
Collections.sort(Arrays.asList(num));//对集合进行排序
Collections.reverse(Arrays.asList(num));//对集合进行反转
for(String str :num)
{
System.out.println(str);
}
第四：设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
eg:public class TestThread {
private int j = 0;

public synchronized void addj() {
j++;
System.out.println("线程" + Thread.currentThread().getName() + "j:=" + j);
}

public synchronized void delj() {
j--;
System.out.println("线程" + Thread.currentThread().getName() + "j:=" + j);
}

class A implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
addj();
}

}
}

class B implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
delj();
}
}
}

public static void main(String[] args) {
for (int i = 0; i < 2; i++) {
TestThread.A a = new TestThread().new A();
Thread thread1 = new Thread(a);
thread1.start();
TestThread.B b = new TestThread().new B();
Thread thread2 = new Thread(b);
thread2.start();
}

}
}

1.java中内部类的好处具体体现在什么地方?

1.可以使内部类中的变量受到保护，受到访问的限制。

2.当内部类和接口一起使用时可以实现多继承。

2.匿名内部类可以继承类吗，可以实现接口吗?

答：匿名类不类不能继承，但可以实现接口。

3.编写一个匿名内部类的例子。


4.public class OutClass
{

public void OutMethod()
{
//3
}

public class InnerClass{}

public static void mian(String [] args)
{
OutClass out =new OutClass();
//8
}
}
在3和8出能够插入正确代码选项为？

A new InnerClass(); //3

B new InnerClass();//8

C new OutClass.InnerClass(); // 8

D new out.InnerClass();//8

E out.new InnerClass();//3


5.

public class OutClass
{

private double num=1.0;
//
}

A
public class innerClass{
public static double model()
{
return num;
}
}

B
public class innerClass{
protected static double model()
{

return num;
}
}

C
public class innerClass{
public double model()
{
return num;
}
}
D
public static class innerClass
{
public double model()
{
return num;
}
}


E
abstract class innerClass{
abstract double model();
}

如果将num变为静态变量, 答案可以选择那几个?

总结：// 1.非静态内部类中的非静态方法能访问外部类中的静态变量和变量。非静态内部类中的静态方法不能访问静态变量和变量。

// 2. 静态内部类中不能访问外部的非静态变量。