JAVA常見問題總計 高級類特性1

  1. java類是否可以多繼承,怎么實現多繼承?

    答:java沒有多繼承,但可以通過接口的形式來達到多繼承的目地。

  2. 我比較兩個String總是false,但是它們明明都是"abc" !

    答:比較String一定要使用 equalsequalsIgnoreCase 方法,不要使用 “==” !
      
      == 比較的是兩個引用(變量)是否指向了同一個對象,而不是比較其內容。

  3. int 和 Integer 有什么區別

    答:Java 提供兩種不同的類型:引用類型和原始類型(或內置類型)。
    Int是java的原始數據類型,Integer是java為int提供的封裝類。Java為每個原始類型提供了封裝類。

    原始類型封裝類,booleanBoolean,charCharacter,byteByte,shortShort,intInteger,longLong,floatFloat,doubleDouble

    引用類型和原始類型的行為完全不同,并且它們具有不同的語義。
    引用類型和原始類型具有不同的特征和用法,它們包括:大小速度 問題,這種類型以哪種類型的數據結構存儲,當引用類型和原始類型用作某個類的實例數據時所指定的缺省值: 對象引用實例變量的缺省值為 null,而原始類型實例變量的缺省值與它們的類型有關.

  4. 定義類A 和類B 如下:【基礎】

    class A {
        int a=1;
        double d=2.0;
        void show(){
            System.out.println("Class A: a="+a +"\td="+d);
        }
    }
    class B extends A{
        float a=3.0f;
        String d="Java program.";
        void show(){
            super.show( );
            System.out.println("Class B: a="+a +"\td="+d);
        }
    }
    

(1) 若在應用程序的 main 方法中有以下語句,則輸出的結果如何?

```
A a=new A();
a.show();
```

(2) 若在應用程序的 main 方法中定義類B 的對象b,則輸出的結果如何?

```
A b=new B();
b.show();
```
答:輸出結果為:
1)Class A: a=1 d=2.0 
2)Class A: a=1 d=2.0
Class B: a=3.0 d=Java program。
  1. 下列代碼運行結果如何?

    public void testString(){
        String str1 = "尚硅谷";
        String str2 = "尚硅谷";
        String str3 = new String("尚硅谷");
        System.out.println(str1 == str2);//true
        System.out.println(str1 == str3);//false
        System.out.println(str1.equals(str3));//true
        str1 = "尚硅谷atguigu.com";
        String str4 = "atguigu.com";
        String str5 = "尚硅谷" + "atguigu.com";
        System.out.println(str1 == str5);//true
        
        String str6 = (str2 + str4).intern();
        System.out.println(str1 == str6);//false  ---->true
    }
    
  2. 重載(overload)和重寫(override,有的書也叫做“覆蓋”)的區別?Overload的方法是否可以改變返回值的類型?

    答:方法的重寫Override和重載Overload是Java多態性的不同表現。
    重寫Override是父類與子類之間多態性的一種表現,
    重載Overload是一個類中多態性的一種表現。
    如果在子類中定義某方法與其父類有相同的名稱和參數,我們說該方法被重寫 (Override)。子類的對象使用這個方法時,將調用子類中的定義,對它而言,父類中的定義如同被"屏蔽"了。
    如果在一個類中定義了多個同名的方法,它們或有不同的參數個數或有不同的參數類型,則稱為方法的重載(Overload)。Overloaded的方法是可以改變返回值的類型。

  3. 寫出程序結果

    class Test
    {
        Test()
        {
            System.out.println("Test");
        }
    }
    class Demo extends Test
    {
        Demo()
        {
            //super();
            System.out.println("Demo");
        }
        public static void main(String[] args)
        {
            new Demo();
            new Test();
        }
    }
    
    // 運行結果
    Test
    Demo
    
    Test
    
  1. 寫出程序結果(多態)

    class  A {
        private int a;
        public void setA(int a){
             this.a = a;
       }
       public int getA(){
           return a;
       }
    }
    class B extends A {
     private int a;
        public void setA(int a){
            this.a = a;
       }
       // public int getA(){
     //    return a;
        //}
    }
    public class TestPerson {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            A c = new B();
    
            c.setA(5);
    
            System.out.println(c.getA());
            
        }
    
    }
    //執行結果:
    0
    
  2. 寫出程序結果

    class Fu
    {
        boolean show(char a)
        {
            System.out.println(a);
            return true;
        }
    }
    class Demo extends Fu
    {
        public static void main(String[] args)
        {
            int i=0;
            Fu f=new Demo();
            Demo d=new Demo();
            for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
            {
                i++;
                d.show('D');
            }   
        }
        boolean show(char a)
        {
            System.out.println(a);
            return false;
        }
    }
    A B
    
  3. 寫出程序結果:

    class Super
    {
        int i=0;
        public Super(String a)
        {
            System.out.println("A");
            i=1;    
        }
        public Super()
        {
            System.out.println("B");
            i+=2;
        }
    }
    class Demo extends Super
    {
        public Demo(String a)
        {
            //super();
            System.out.println("C");
            i=5;                
        }
        public static void main(String[] args)
        {
            int i=4;
            Super d=new Demo("A");
            System.out.println(d.i);
        }
    }
    執行結果:B C 5
    
  4. 寫出程序結果:

    interface Inter
    {
        void show(int a,int b);
        void func();
    }
    class Demo
    {
        public static void main(String[] args)
        {
            //補足代碼;調用兩個函數,要求用匿名內部類
            Inter in = new Inter()
            {
                public void show(int a,int b)
                {
                
                }
                public void func()
                {
                
                }
            };
    
            in.show(4,5);
            in.func();
            
        }
    }
    
  5. ??選擇題,寫出錯誤答案錯誤的原因,用單行注釋的方式。

    class Demo
    {
         int show(int a,int b){return 0;}
    }
    

    下面那些函數可以存在于Demo的子類中。

    A.public int show(int a,int b){return 0;}//可以,覆蓋。
    B.private int show(int a,int b){return 0;}//不可以,權限不夠。
    C.private int show(int a,long b){return 0;}//可以,和父類不是一個函數。沒有覆蓋,相當于重載。
    D.public short show(int a,int b){return 0;}//不可以,因為該函數不可以和給定函數出現在同一類中,或者子父類中。
    E.static int show(int a,int b){return 0;}//不可以,靜態只能覆蓋靜態。

  1. 寫出程序結果:

    class Fu
    {
        int num=4;
        void show()
        {
            System.out.println("showFu");
        }
    }
    class Zi extends Fu
    {
        int num=5;
        void show()
        {
            System.out.println("showZi");
        }
    }
    class T
    {
        public static void main(String[] args)
        {
            Fu f=new Zi();
            Zi z=new Zi();
            System.out.println(f.num); 
            System.out.println(z.num); 
            f.show(); 
            z.show();   
        }
    }
    執行結果:
    4
    5
    showZi
    showZi
    
  2. 寫出程序結果

    class Super
    {
        int i=0;    
        public Super(String s)
        {
            i=1;    
        }
    }
    class Demo extends Super
    {
        public Demo(String s)
        {
            i=2;            
        }
        public static void main(String[] args)
        {
            Demo d=new Demo("yes");
            System.out.println(d.i);
        }
    }
    //編譯失敗,因為父類中缺少空參數的構造函數。
    //或者子類應該通過super語句指定要調用的父類中的構造函數。
    
  3. 寫出程序結果

    class Super
    {
        public int get(){return 4;}
    }
    class Demo15 extends Super
    {
        public long get(){return 5;}            
        public static void main(String[] args)
        {
            Super s=new Demo15();
            System.out.println(s.get());
        }
    }
    
    編譯失敗,因為子類父類中的get方法沒有覆蓋。但是子類調用時候不能明確返回的值是什么類型。
    所以這樣的函數不可以存在子父類中。
    
  4. 繼承時候類的執行順序問題,一般都是選擇題,問你將會打印出什么?
    答:

    父類:
    package test;
    public class  FatherClass
    {
        public FatherClass()
        {
            System.out.println("FatherClass Create");
        }
    }
    子類:
    package test;
    import test.FatherClass;
    public class  ChildClass extends FatherClass
    {
        public ChildClass()
        {
            System.out.println("ChildClass Create");
        }
        public static void main(String[] args) 
        {
            FatherClass fc = new FatherClass();
            ChildClass cc = new ChildClass();
        }
    }
    當執行如下操作
    C:\>java test.ChildClass
    輸出結果為:
    FatherClass Create
    FatherClass Create
    ChildClass Create 
    
  5. 觀察下面代碼

    public class OuterClass { 
      private double d1 = 1.0; 
        //insert code here 
    } 
    You need to insert an inner class declaration at line 3.
    Which two inner class declarations are valid?(Choose two.) 
    A. class InnerOne{
         public static double methoda() {return d1;}
       } 
    B. public class InnerOne{
         static double methoda() {return d1;}
       } 
    C. private class InnerOne{
         double methoda() {return d1;}
       } 
    D. static class InnerOne{
         protected double methoda() {return d1;}
       } 
    E. abstract class InnerOne{
         public abstract double methoda();
       } 
    說明如下:
    一.靜態內部類可以有靜態成員,而非靜態內部類則不能有靜態成員。 故 A、B 錯
    二.靜態內部類的非靜態成員可以訪問外部類的靜態變量,而不可訪問外部類的非靜態變量;return d1 出錯。 
    故 D 錯
    三.非靜態內部類的非靜態成員可以訪問外部類的非靜態變量。 故 C 正確
    四.答案為C、E 
    
  6. 觀察下列代碼

1. public class Test {
2.      int x = 12;
3.      public void method(int x) {
4.          x += x;
5.          System.out.println(x);
6.      }
7. }

Given:
34. Test t = new Test();
35. t.method(5);

What is the output from line 5 of the Test class?
A. 5
B. 10
C. 12
D. 17
E. 24

結果:B
最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。