Java基础知识(一) 基本概念

ゝ一纸荒年。 2022-09-02 00:46 264阅读 0赞

### Java基础知识 ###

*  基本概念
 *   *  1. Java语言的优点
     *  2. Java与c/c++有什么异同
     *  3. 为什么需要public static void main(String\[\] args)这个方法
     *  4. Java程序的初始化的顺序是怎么样的
     *  5. Java中的作用域
     *  6. 一个Java文件中是否可以定义多个类
     *  7. 什么构造函数
     *  8. 为什么Java中有些接口没有任何方法
     *  9. Java中的clone方法有什么作用
     *  10. 什么是反射机制
     *  11.如何实现类似于C语言中函数指针的功能

[下一篇：Java基础知识(二) 面向对象的技术][Java_]

# 基本概念 #

## 1. Java语言的优点 ##

1.  Java语言是纯面向对象的语言
2.  平台无关性
3.  Java提供了很多内置类库
4.  提供了对web应用开发的支持
5.  具有较好的安全性和健壮性
6.  去除了C++语言中难以理解，容易混淆的特性，使程序更加严谨，简洁

## 2. Java与c/c++有什么异同 ##

1.  Java与C++都是面向对象的语言，都使用了面向对象的思想（封装、继承、多态）
2.  Java为解释性语言
3.  Java为纯面向对象的语言，所有代码（包括函数、变量等）必须在类中实现，除了基本类型（包括int、float等）外，所有类型都是类。
4.  ···

## 3. 为什么需要public static void main(String\[\] args)这个方法 ##

main是JVM识别的特殊方法名，是程序的入口方法，程序开始执行时，没有实例化的对象，所以main()方法需要被定义成public和static才能执行。

## 4. Java程序的初始化的顺序是怎么样的 ##

Java程序初始化的原则：

1.  静态对象（变量）优先于非静态对象（变量）初始化，其中，静态对象（变量）只初始化一次，而非静态对象（变量）可能初始化多次
2.  父类优先于子类进行初始化
3.  按照成员变量的定义顺序进行初始化

Java程序的代码块顺序

1.  父类静态变量
2.  父类静态代码块
3.  子类静态变量
4.  子类静态代码块
5.  父类非静态变量
6.  父类非静态代码块
7.  父类构造函数
8.  子类非静态变量
9.  子类非静态代码块
10. 子类构造函数

初始化程序示例

/** * 创建时间 2021/7/29 11:20 * 初始化顺序 * @author Ye * @version 1.0 */
    class Base { 
        static { 
            System.out.println("Base static block");
        }
        { 
            System.out.println("Base block");
        }
    
        public Base(){ 
            System.out.println("Base constructor");
        }
    }
    
    public class Derived extends Base{ 
        static { 
            System.out.println("Derived static block");
        }
        { 
            System.out.println("Derived block");
        }
        public Derived(){ 
            System.out.println("Derived constructor");
        }
    
        public static void main(String[] args) { 
            new Derived();
        }
    }

运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUyMDY3MA_size_16_color_FFFFFF_t_70]

## 5. Java中的作用域 ##

Java中，变量的类型主要有3种：成员变量、静态变量和局部变量。类的成员变量的作用范围与类的实例化对象的作用范围相同。static修饰的成员变量称为静态变量或者全局变量，静态变量不依赖于特定实例，被所有实例共享。局部变量的作用域与可见性在它的花括号内。

成员变量的4种作用域

<table> 
 <thead> 
  <tr> 
   <th>作用域 与可见性</th> 
   <th>当前类</th> 
   <th>同一package</th> 
   <th>子类</th> 
   <th>其他package</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public</td> 
   <td>1</td> 
   <td>1</td> 
   <td>1</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>1</td> 
   <td>0</td> 
   <td>0</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>1</td> 
   <td>1</td> 
   <td>1</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>1</td> 
   <td>1</td> 
   <td>0</td> 
   <td>0</td> 
  </tr> 
 </tbody> 
</table>

## 6. 一个Java文件中是否可以定义多个类 ##

一个Java文件中可以定义多个类，但是最多只能有一个类被public修饰，并且这个类的类名与文件名必须相同。

## 7. 什么构造函数 ##

构造函数是一种特殊的函数，用来在对象实例化初始化对象的成员变量。在Java语言中，构造函数的特点如下：

1.  构造函数必须与类的名字相同，并且不能有返回值（返回值也不能为void）
2.  每个类可以有多个构造函数
3.  构造函数可以有0个，1个或者1个以上的参数
4.  构造函数总是伴随着new操作一起调用，且不能由程序的编写者直接调用，必须由系统调用
5.  构造函数主要作用是完成对象的初始化工作
6.  构造函数不能被继承
7.  当父类没有提供无参构造函数时，子类构造函数必须通过super显式的调用父类的构造函数

## 8. 为什么Java中有些接口没有任何方法 ##

由于Java不支持多重继承，经常采用实现多个接口来间接达到多重继承的目的。在Java语言中，有些接口没有任何方法，这些没有方法的接口又被叫标识接口，标识接口对它的类没有任何语义要求，它仅仅充当一个标识的作用。

## 9. Java中的clone方法有什么作用 ##

Java中基本数据类型是按值传递，除此之外都是引用传递。在实际的编程中，经常需要创建一个与已经存在的对象具有相同状态的对象，clone的作用就在与此。实现方法：

1.  实现Cloneable接口（标识接口）
2.  重写Object中的clone()方法
3.  在clone方法中调用super.clone()
4.  把浅复制的引用指向原型对象新的克隆体

浅复制是指只复制一个对象，但是不复制对象的当前状态  
浅复制代码示例：

/** * 创建时间 2021/7/29 17:30 * clone浅复制 * @author Ye * @version 1.0 */
    
    class Copy implements Cloneable{ 
        private int data = 0;
    
        public int getData(){ 
            return data;
        }
    
        public void setData(int data) { 
            this.data = data;
        }
    
        public void changeData(){ 
            data = 1;
        }
    
        @Override
        public Object clone(){ 
            Object obj = null;
            try{ 
                obj = (Copy)super.clone();
            }catch (Exception e){ 
                e.printStackTrace();
            }
            return obj;
        }
    }
    
    public class TestRef { 
        public static void main(String[] args) { 
            Copy copy = new Copy();
            Copy copy1 = (Copy)copy.clone();
            copy1.changeData();
            System.out.println("copy: "+copy.getData());
            System.out.println("copy1: "+copy1.getData());
        }
    }

运行截图：  
![在这里插入图片描述][26cad74253da4a6c90ac81aeb808df49.png]  
深复制：指既复制对象又复制对象的状态  
深复制示例代码：

import java.util.Date;
    
    /** * 创建时间 2021/7/29 18:28 * 深复制 * @author Ye * @version 1.0 */
    class Obj implements Cloneable{ 
        private Date birth = new Date();
    
        public Date getData(){ 
            return birth;
        }
    
        public void setData(Date birth) { 
            this.birth = birth;
        }
    
        public void changeData(){ 
            this.birth.setTime(100000);
        }
    
        @Override
        public Object clone(){ 
            Object obj = null;
            try{ 
                obj = (Obj)super.clone();
            }catch (Exception e){ 
                e.printStackTrace();
            }
            //实现深复制
            ((Obj) obj).birth = (Date)this.birth.clone();
            return obj;
        }
    }
    /** * 创建时间 2021/7/29 18:28 * 深复制 * @author Ye * @version 1.0 */
    public class TestRef1 { 
        public static void main(String[] args) { 
            Obj obj = new Obj();
            Obj obj1 = (Obj) obj.clone();
            obj1.changeData();
            System.out.println("obj: " + obj.getData());
            System.out.println("obj1: " + obj1.getData());
        }
    }

运行截图：  
![在这里插入图片描述][6dbd22a23d1447fbbeffea39033ff2c8.png]

## 10. 什么是反射机制 ##

反射机制是Java语言中一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部成员进行操作。反射机制的主要功能有：

*  得到一个对象所属的类
 *  获取一个类的所有成员变量和方法
 *  在运行时创建对象
 *  在运行时调用对象的方法

代码示例：

class Base1{ 
        public void fun(){ 
            System.out.println("Base");
        }
    }
    
    class Sub1 extends Base1{ 
        @Override
        public void fun(){ 
            System.out.println("Sub");
        }
    }
    
    /** * 创建时间 2021/7/29 19:15 * 反射测试 * @author Ye * @version 1.0 */
    public class ReflectionTest { 
        public static void main(String[] args) { 
            try{ 
                // 使用反射机制加载类
                Class sub = Class.forName("com.test.test.Sub1");
                Base1 base = (Base1)sub.newInstance();
                base.fun();
            }catch (Exception e){ 
                e.printStackTrace();
            }
        }
    }

运行截图：  
![在这里插入图片描述][7dc2ee9ba5514d55890bfd782eb8ddbf.png]  
Java创建对象的4种方法：

1.  通过new语句实例化一个对象
2.  通过反射机制创建对象
3.  通过clone()创建一个对象
4.  通过反序列化的方式创建对象

## 11.如何实现类似于C语言中函数指针的功能 ##

可以先定义一个接口，在接口中声明一个要调用的方法，接着实现这个接口，最后把这个实现类的一个对象作为参数传递给调用程序，调用程序通过这个参数来调用指定的函数，从而实现回调函数的功能。

具体代码如下：

interface IntCompare{ 
        public int cmp(int a,int b);
    }
    
    class Cmp1 implements IntCompare{ 
    
        @Override
        public int cmp(int a, int b) { 
            if (a > b){ 
                return 1;
            }else if (a < b){ 
                return -1;
            }else { 
                return 0;
            }
        }
    }
    
    class Cmp2 implements IntCompare{ 
    
        @Override
        public int cmp(int a, int b) { 
            if (a > b){ 
                return -1;
            }else if (a < b){ 
                return 1;
            }else { 
                return 0;
            }
        }
    }
    
    /** * 创建时间 2021/7/29 19:56 * java实现类似指针功能 * @author Ye * @version 1.0 */
    public class Test3 { 
        public static void insertSort(int[] a,IntCompare cmp){ 
            if (a != null){ 
                for (int i=1;i<a.length;i++){ 
                    int temp = a[i],j = i;
                    if (cmp.cmp(a[j-1],temp) == 1){ 
                        while (j >= 1 && cmp.cmp(a[j-1],temp) == 1){ 
                            a[j] = a[j-1];
                            j--;
                        }
                    }
                    a[j] = temp;
                }
            }
        }
    
        public static void main(String[] args) { 
            int[]  array1 = { 8,9,6,5,2,1,3};
            insertSort(array1,new Cmp1());
            System.out.print("升序排序： ");
            for (int i = 0;i < array1.length;i++){ 
                System.out.print(array1[i] + " ");
            }
            System.out.println();
            int[]  array2 = { 8,9,6,5,2,1,3};
            insertSort(array2,new Cmp2());
            System.out.print("降序排序： ");
            for (int i = 0;i < array2.length;i++){ 
                System.out.print(array2[i] + " ");
            }
        }
    }

运行截图：  
![在这里插入图片描述][42c76822469240ad9e3830e94d54a278.png]

参考：《Java程序员面试笔试宝典》 何昊、薛鹏、叶向阳 编著

[Java_]: https://blog.csdn.net/weixin_43520670/article/details/119236405
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUyMDY3MA_size_16_color_FFFFFF_t_70]: /images/20220829/1eba805b5181495293db86fbec4291f9.png
[26cad74253da4a6c90ac81aeb808df49.png]: /images/20220829/cb49b6861c5d409d8c2a4797d4140d80.png
[6dbd22a23d1447fbbeffea39033ff2c8.png]: /images/20220829/aa57376e79924775a08c4ffd120f122c.png
[7dc2ee9ba5514d55890bfd782eb8ddbf.png]: /images/20220829/a798ca7adbdb4e6c9de5073f5990495e.png
[42c76822469240ad9e3830e94d54a278.png]: /images/20220829/549f6627aa6344ce8ac41c9898981115.png