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. 静态内部类中不能访问外部的非静态变量。