java重点知识

Posted 2020-10-31 Wayne Zhu

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java重点知识相关的知识，希望对你有一定的参考价值。

一、java基本知识点

java是由SUN公司在1995年推出的，在2009年SUN公司又被甲骨文公司收购，所以甲骨文公司获得java版权。其底层是由C语言写的，java分为三个体系：

JavaSE，即Java Platform Standard Edition，java平台标准版。
JavaEE，即Java Platform Enterprise Edition，java平台企业版。
JavaME，即Java Platform Micro Edition，java平台微型版。

　　其中JavaSE标准版更多的是基础语法，而JavaEE是用于企业的，扩展了其他的一些功能，可以说JavaSE是JavaEE的子集。而JavaME用的很少，不做讨论。

另外，java有下面的特性比较重要：

简单。其语法和C++接近，但是没有用操作符重载、多继承、指针等比较复杂的概念，并且提供了自动的垃圾收集机制，和javascript类似。
面向对象。 java最大的特点就是面向对象。提供了类、接口、继承等概念。
分布式语言。支持Internet应用的开发，在基本的Java应用编程接口中有一个应用编程接口（java net）。
中立的体系结构。java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个java平台的任何系统中运行。
支持多线程。和JavaScript的单线程不同，java语言支持多线程，通过Thread类来创建。

二、java开发工具以及安装配置

（1）jvm、jre、jdk、sdk、eclipse区别和联系。

　 JDK（Java Development Kit）是Java语言的开发工具包（SDK）。在JDK的安装目录下有一个jre目录，里面有两个文件夹bin和lib，在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和lib合起来就成为jre。

　 JRE（Java Runtime Environment）即java运行环境，包含JVM标准实现以及Java核心类库。JRE是Java的运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器）。

　 JVM（Java VIrtual Machine）即java虚拟机，JVM是一种用于计算设备的规范，是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

（参考自文章：https://blog.csdn.net/songkai320/article/details/51819046）

　如上，所以JDK是整个Java的核心，而JRE是Java程序必须的环境的集合，包含了JVM标准实现和Java核心类库。JVM是整个java实现跨平台的最核心的部分，能够运行以Java语言写的程序。

　而eclipse是方便我们写java程序的开发工具，它不是必须的，就像我们写前端html页面，你可以使用记事本来写，当然也可以使用sublime这种开发工具来写。

（2）java开发环境配置

　　我们可以在oracle公司网站上下载jdk，进入之后选择与本机操作系统对应的jdk文件即可，且在安装jdk的同时会提示安装jre，直接安装即可。

　在cmd中运行 java -version、java、javac几个命令，出现了相关信息，没有报错，就说明环境变量配置成功。

　　我在安装java环境的时候，首先安装到了D盘新建的Java中，然后中间又在安装什么没有看清楚，安装到了c盘program files下面的java中。安装完成之后cmd中输入java --version是可以成功的，输入java也显示了很多内容，但是输入javac时不能正确识别，然后，我将 D:\\java\\bin 也加入了环境变量，就都可以识别了。如下所示：

　　如上，如果javac和java两者都成功运行，那么基本的java环境就搭好了，如果想要运行文件，只需要用一个记事本写java程序然后通过命令行运行即可。

　　工具下载可以在网站 https://down.eeyes.net 上下载，更加正规，不存在有病毒的可能。

（3）JAVA开发工具

　　Eclipse是免费开源的java IDE，是绝大多数开发者的选择，选择Eclipse IDE for Java Developers即可。其他的编辑器也很多，比如notepad++以及netbeans等。这里我们还是推荐使用Eclipse。

　　而如果要开发安卓app，一般使用的是 android Studio，因为相对来说Eclipse更加臃肿，所以开发安卓推荐 Android Studio。

三、第一个例子

　　我们随意打开一个编辑器，创建FOO.java文件，文件中的代码如下所示：

public class FOO {
    public static void main(String[] args) {
        System.out.println("hello world!");
    }
}

　　然后因为我们这里还没有使用IDE（如eclipse），所以可以使用命令行编译运行，如下：

　即我们首先使用javac命令（即java compile）进行编译文件，然后使用java命令来执行文件。

　 注意：类名必须和文件名保持一致，即该文件名必须为FOO.java。

　　接下来，我们使用eclipse创建一个java程序，如下：

　　先创建一个java project：

　　然后我们创建一个class：

　　然后在创建class时，需要右键src，package就自动创建好了，然后结果如下：

　　即首先创建一个foo工程，在src文件并列的有JRE System Library，然后在src下创建一个foo包，这个包中创建一个Foo.java类即可，类下代码如下：

package foo;

public class FOO {
    public static void main (String[] args) {
        System.out.println("wayne");
    } 
}

　　然后点击运行，如下：

　　最后结果如下：

　　即在console控制台中打印出了最终结果。

四、java基础语法

（1）基础部分

大小写敏感。
类名首字母要大写，且类名使用的是大驼峰式写法。
方法名必须要以小写字母开头。
源文件名必须要和类名相同，后缀是java，如果文件名和类名不同则会导致编译错误。
主文件入口：所有的Java程序都必须由 public static void main(String []args)方法开始执行。

（2）变量

　　java中的变量有局部变量、类变量（静态变量）以及成员变量（非静态变量）。其中局部变量就是一般函数中的变量，而静态变量是类中的变量，但是静态变量的特点是用static修饰了，且不需要通过实例来引用这个变量，而非静态变量是类中没有使用static修饰的变量，并且非静态变量必须要通过实例来引用。

（3）关键字

　　java中的关键词和其他语言关键字也都是大同小异，比如private、protected、public、class、extends、interface、static、break、for、case、do、try、void、goto等等等等。

（4）注释

　　注释和JavaScript一样，使用 // 作为单行注释，使用 / * */作为多行注释。当然，这些注释行和所有的空白行都会被java编译器在编译的过程中直接忽略。

（5）接口

　　在java中，接口可以理解为对象之间相互通信的协议。接口在继承中扮演着非常重要的角色，接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

（6）java源程序与编译型运行区别

编译型语言。如c/c++，他们通过编译器直接编译为exe可执行文件，然后在运行的时候就可以直接运行，而不需要解释，所以速度很快。
解释型语言。如java、JavaScript，java写完之后编译为class文件，然后这个文件是不能直接运行的，还需要再运行的时候边解释边运行，所以速度较慢。

五、java对象和类

　　面向对象的语言不只是java，还有c++、python之类的，所以在理解起来都是没有问题的，大同小异。比如对象是类的一个实例，它有状态（属性）和行为（方法），而类是一个模板，这个模板它描述了一类对象的行为和状态。在我们创建第一个java程序时，我们就使用到了类，即public class 类名 {} 。

　　而java中的变量（这里不是类的变量）有多种，即局部变量、成员变量、类变量。如在方法中定义的变量，就是局部变量，因为它会在方法执行完成之后立即被销毁，这就是局部变量；而成员变量是定义在类中、方法体之外的变量。这种变量在创建对象的时候实例化，它可以被类中方法、构造方法和特定类的语句块访问；而类变量也是生命在类中的，方法体之外，但必须声明为static类型，且不是被实例访问，而是类访问的。

　　而java中的构造方法和c++中的构造函数是类似的，他们都是为了更加方便的构造实例，并且两者的构造函数如果开发者没有定义就会自动提供一个默认的构造函数，且构造方法和类的名称必须要同名，一个类可以有多个构造方法。

　　如下所示，创建一个Puppy类，这个类中含有两个构造方法：

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

　　而如下所示的程序就可以创建一个实例：

public class FOO {
    public FOO(String name) {
        // 构造方法，创建一个实例时输出其名称
        System.out.println("create a new object:" + name);
    }
    public static void main(String[] args) {
        FOO foo = new FOO("wayne");
    } 
}

　　但是在运行时时会发生编译错误，即无法正常解码，我们使用 -encoding UTF-8 的编码方式即可，如下所示：

PS C:\\Users\\Administrator\\Desktop> javac -encoding UTF-8 FOO.java
PS C:\\Users\\Administrator\\Desktop> java FOO
create a new object:wayne

　　这样，我们就可以得到争取的结果了。

　　另外，如果我们希望访问属性和方法也可以通过下面的方式进行访问：

public class FOO {
    public FOO(String name) {
        // 构造方法，创建一个实例时输出其名称
        System.out.println("create a new object:" + name);
    }
    int fooAge;
    public void setAge(int age) {
        fooAge = age;
    }
    public int getAge() {
        System.out.println("the age is:" + fooAge);
        return fooAge;
    }
    public static void main(String[] args) {
        FOO foo = new FOO("wayne");
        foo.setAge(22);
        foo.getAge();
    } 
}

　　如上所示，通过int Age就可以创建一个实例变量，方法也是类似的，最后我们在public static void main函数中执行主要的逻辑，通过foo.setAge和foo.getAge来调用实例方法。最后结果如下：

PS C:\\Users\\Administrator\\Desktop> javac -encoding UTF-8 FOO.java
PS C:\\Users\\Administrator\\Desktop> java FOO
create a new object:wayne
the age is:22

　　ok，到这里，我们就对java中基本的类、实例、属性、方法等有一个基本的了解了。

六、其他相关规则（源文件、包）

　　即我们在一个.java这样的源文件中是要遵循相应的规则的，比如说一个源文件只能有一个public类、但是一个源文件可以有多个非public类、源文件的名称应该和publick类的类名保持一致、如果一个类定义在了某个包中那么package语句应该在源文件的首行、而如果源文件包含import语句，那么应该放在package语句和类定义之间；如果没有package语句，那么import语句应该放在源文件中最前面、import语句和package语句对源文件中定义的所有类都有效。

　　java包的主要作用是对类和接口进行分类，当开发java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

　　在java中，如果给出一个完整的限定名，包括包名、类名，那么java编译器就可以很容易地定位到源代码或者类了，而import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

package和import的区别：

　　两者是互逆的过程，如package freedom.bean语句的作用是将当前的类（class文件）打包到这个freedom.bean包中；而 import freedom.bean.* 就是把freedom.bean这个包中的所有类都引入，这样就可以使用了，比如我们是可以引用到之前package freedom.bean的类的。

　　又如，我们通过import java.io.*就可以导入输入输出相关的所有类。　　

　　下面，我们通过一个例子来进行进一步的讲解，这个例子中，我们创建Employee和Employee Test两个类。

　　首先，我们创建Employee.java文件，如下：

import java.io.*;
 
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("名字:"+ name );
      System.out.println("年龄:" + age );
      System.out.println("职位:" + designation );
      System.out.println("薪水:" + salary);
   }
}

　　然后，创建EmployeeTest.java如下：

import java.io.*;
public class EmployeeTest{
 
   public static void main(String args[]){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
 
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();
 
      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

　　注意：前两个文件要放在同一个文件夹下。

　　最后，我们直接运行即可，最终结果如下：

PS C:\\Users\\Administrator\\Desktop> javac -encoding UTF-8 EmployeeTest.java
PS C:\\Users\\Administrator\\Desktop> java EmployeeTest
名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0

　　所以，我们可以发现，创建了Employee.java这个类之后，我们并不需要package将之打包，也不需要在EmployeeTest.java中使用import引用，而是如果两者在同一个文件夹下，那么就可以直接在一个文件中调用另外一个类。并且，要通过上述的运行，我们即使不使用 import java.io.* 也是可以正常执行的。但是，如果我们没有将两者放在同一个文件夹下，就会出现问题，而不能正常执行。

七、java基本数据类型

　　java中也分为了两种数据类型，一种是内置数据类型，另外一种是引用数据类型，这个和JavaScript是一样的。

　　但js中的基本数据类型有5种，而java中的基本数据类型却有8种（四个整数型、两个浮点型、一种字符类型、一种布尔型）。

byte数据类型。它是8位、有符号的、以二进制补码表示的整数，最小值为-128，最大值为127，默认值为0. byte类型占用的空间只有int类型的四分之一。
short数据类型。它是16位、有符号的、以二进制补码表示的整数，最小值是-32768（-2^15），最大值是32767（2^15 - 1），short类型和byte类型一样都很节省空间，因为short变量是int变量所占空间的二分之一。它的默认值也是0.
int数据类型。它是32位、有符号的以二进制补码表示的整数，最小值为-2^31，最大值是2^31 - 1，一般整型变量默认就是int类型，默认值为0。
long数据类型。它是64位、有符号的以二进制补码表示的整数，最小值为-2^63，最大值为2^63 - 1，这种类型主要使用在需要比较大整数的系统上。默认值为0L。比如 long a = 100000L。
float数据类型。它是单精度、32位、符合IEEE 754标准的浮点数。它在储存大型浮点数组的时候可以节省内存空间，默认值为0.0f，它不能用来表示精确的值，如货币。如float f1 = 234.5f。
double数据类型。它是双精度、64位、符合IEEE 754标准的浮点数。浮点数的默认类型就是double类型。它同样不能表示精确的值，如货币。默认值是0.0d。如double d1 = 123.4。
boolean数据类型。它表示一位的信息，只有两个取值：true和false。这种类型只作为记录true/false情况，默认值是false。比如boolean one = true。
char类型。char类型是一个单一的16位的Unicode字符，最小值是 \\u0000（即为0），最大值是 \\uffff（即为65535），char数据类型可以存储任何字符，比如char letter = \'A\'；。

　　如上，就是四类8种基本数据类型了。在上面的详细介绍中，有其最大最小值的限制，而实际上，我们根本就不不要记住，而是通过MIN_VALUE和MAX_VALUE就可以获取到了。如下所示：

public class FOO {
    public static void main (String[] args) {
        System.out.println("基本类型: byte二进制位数: " + Byte.SIZE);
        System.out.println("包装类: java.lang.Byte");
        System.out.println("最大值: Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最小值: Byte.MAX_VALUE=" + Byte.MAX_VALUE );
        System.out.println();

        System.out.println("基本类型: int二进制位数: " + Integer.SIZE);
        System.out.println("包装类: java.lang.Integer");
        System.out.println("最大值: Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最小值: Integer.MAX_VALUE=" + Integer.MAX_VALUE );
        System.out.println();

        
        System.out.println("基本类型: char二进制位数: " + Character.SIZE);
        System.out.println("包装类: java.lang.Character");
        System.out.println("最大值: Character.MIN_VALUE=" + (int)Character.MIN_VALUE);
        System.out.println("最小值: Character.MAX_VALUE=" + (int)Character.MAX_VALUE );
        System.out.println();
    }
}

　　即我们可以通过如上的方式获取到java中基本数据类型的范围，结果如下：

基本类型: byte二进制位数: 8
包装类: java.lang.Byte
最大值: Byte.MIN_VALUE=-128
最小值: Byte.MAX_VALUE=127

基本类型: int二进制位数: 32
包装类: java.lang.Integer
最大值: Integer.MIN_VALUE=-2147483648
最小值: Integer.MAX_VALUE=2147483647

基本类型: char二进制位数: 16
包装类: java.lang.Character
最大值: Character.MIN_VALUE=0
最小值: Character.MAX_VALUE=65535

　　上面说了8种都是java中的基本数据类型，下面是java中的引用类型。java中的应用类型非常类似于c/c++中的指针，引用类型指向一个对象，指向对象的变量是引用变量，这些变量声明时被指定为一个特定的类型，比如Employee、Puppy等。注意：对象、数组都是引用类型，所有引用类型的默认值都是null，一个引用变量可以用来引用任何与之兼容的类型。如Site site = new Site("wayne");

　　java常量。java常量在程序运行中是不能被修改的，常量的声明方式和变量类似，使用final关键字，如下：

final double PI = 3.1435926;

　　一般，这个常量的大小写没有限制，但是最好使用大写，便于观察。

　　在java中，字符串常量和字符常量都可以包含任何Unicode字符，例如：

char a = \'\\u0001\';
String a = "\\u0001";

　　java语言支持一些特殊的转义字符序列。

八、java类型转换

　　　整型、常量、字符型数据可以混合运算，运算中，不同的数据类型先转化为同一数据类型，然后进行运算。

　　　转换由低级到高级（而如果从高级到低级转换，就会导致精度丢失了），如下：

低  --------------------------------------->  高

byte,short,char—> int —> long—> float —> double

　　注意，转换过程中也是要遵循一定的规则的：

不能对boolean类型进行类型转换。
不能吧对象类型转换为不想关类的对象。
在把容量大的类型转换为容量小的类型时，必须使用强制类型转换。
转换过程中可能导致溢出或者损失精度，如下：

int i =128;   
byte b = (byte)i;

　　byte类型最大值为127，所以，int类型强制转化为byte类型时，值128时就会导致溢出。

浮点数到整数的转化是通过舍弃小数得到的，而不是四舍五入，如(int)23.7 == 23; 。

　　强制类型转换的条件是转换的数据类型必须是兼容的，比如：

int i = 123;
byte j = (byte)i;

　　这里就将int类型的i强制转化为了byte类型的j了。

九、java中的Number类和Math类

　　在java中，我们可能常常会用到byte、int、long、double等内置数据类型，但是，在实际开发中，我们可能经常会用到它们的对象，因为对象上封装了很多方法，可以方便我们调用，而所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类，而Number类是属于java.lang包的。

　　如下所示：

public class Test {
    public static void main(String[] args) {
        Integer num = 5;
        System.out.println(num);
    }
}

　　编译执行之后就会输出5。这只是一个简单的例子，如果真的只能这么用，还不如直接用int，所以啊，其实Interger包括其他继承自Number类的类都有很多方法可以调用，后面会讲到。

　　另外，Math类也是在数值计算中常常会用到的，java中的Math包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。如下所示：

public class Test {
    public static void main(String[] args) {
        System.out.println("90度的正弦值： " + Math.sin(Math.PI/2));
        System.out.println("0度的余弦值： " + Math.cos(0));
        System.out.println("求2的3次方： " + Math.pow(2, 3));
    }
}

　　最终结果如下所示：

90度的正弦值： 1.0
0度的余弦值： 1.0
求2的3次方： 8.0

　　而下面是Number和Math的一些类方法：

xxxValue() - 如byteValue()可以将Number类型的值转化为基本数据类型的byte类型。
compareTo() - 将number对象与参数进行比较。
equals() - 判断number对象与参数是否相等。
valueOf() - 返回一个Number对象指定的内置数据类型。
toString() - 以字符串的形式返回。
parseInt() - 将字符串转化为int类型。
abs() - 返回参数的绝对值。
ceil() - 返回大于等于给定参数的最小整数。
floor() - 返回小于等于给定参数的最大整数。
rint() - 返回与参数最接近的整数，返回类型为double。
min() - 返回两个参数中的最小值。
max() - 返回两个参数中的最大值。
random() - 返回一个随机数。

十、java中的String类

　　字符串广泛应用在java编程中，在java中字符串属于对象，java提供了String类来创建和操作字符串。

　　如下我们可以创建String对象：

public class Test {
    public static void main(String[] args) {
        String c = "wayne-zhu";
        String b = new String("hedy-he");
        System.out.println(c); // wayne-zhu
        System.out.println(b); // hedy-he
    }
}

　　上面的例子中演示了两种创建String实例的方法，都是正确的。

　　而使用String，是为了使用String类的方法，如下：

public class Test {
    public static void main(String[] args) {
        String c = "wayne-zhu";
        String b = new String("hedy-he");
        int cLen = c.length();
        System.out.println("cLen: " + cLen); // clen: 9

        String d = c.concat(b);
        System.out.println("d: " + d); // d: wayne-zhuhedy-he

        String fs;
        fs = String.format("浮点型变量的值为：%f" + "， 整型变量的值为: %d" + "， 字符型变量的值为: %s", 0.618, 666, "wayne");
        System.out.println(fs);
    }
}

　　最终结果如下所示：

cLen: 9
d: wayne-zhuhedy-he
浮点型变量的值为：0.618000， 整型变量的值为: 666， 字符型变量的值为: wayne

　　另外，String还有其他很多方法：

char charAt(int index)返回指定索引处的char值。
int compareTo(Object o)把这个字符创和另外一个对象比较，返回的是ASCII差值。
int compareTo(String anotherString)按照字典顺序比较两个字符串
int compareToIgnoreCase(String str)按照字典顺序比较，不考虑大小写
String concat(String str)将指定字符串连接到此字符串的结尾。
int indexOf(int ch)返回指定字符串中第一次出现处的索引。

十一、java数组

　　数组在任何编程语言中都是存在的，它用来存储固定大小的同类型元素，这里主要介绍java数组的声明、创建、初始化。

double[] myList; // 首选的方法

double myList[];

　　如上所示，我们声明数组有两种方法，第一种是推荐的方法，第二种也可以，但是不推荐。

上面是声明的过程，但是创建数组要用下面的方法：

double[] myList = new double[10];

　　这里，我们创建了myList数组，且长度为10。

　　当然，我们可以直接赋值，如下所示：

double[] myList = {1.0, 131.1, 2.3, 6.3};

　　另外，数组有for循环可以调用，如果要单独访问到某个元素，可以使用下标进行访问，如下所示：

public class Test {
    public static void main(String[] args) {
        double[] myList = {1.1, 1.2, 1.3, 1.4};
        System.out.println("第一个元素： " + myList[0]);
        for (double element: myList) {
            System.out.println(element);
        }
    }
}

　　最终结果如下所示：

第一个元素： 1.1
1.1
1.2
1.3
1.4

　　另外，数组也可以作为参数被传递，也可以是一个函数的返回值。

十二、java方法

　　在java中，我们之前用到的最多的时System.out.println()，其中：

println()就是一个方法。
out是对象。
System是类。

　　即println()是System类下的out对象的方法。

　　方法其实就是函数，在JavaScript、c++等语言中都是一样的，它可以使得程序变得简洁而清晰、有利于程序维护、可以提高程序开发的效率、提高了代码的重用性。

　　需要注意的是，和JavaScript不同，java对方法的命名有一定的要求：即方法的名字的第一个单词应以小写字母开头，后面的单词则用大写字母开头，不使用连接符，例如addPerson；下划线可能出现在JUnit测试方法名称用以分隔名称的逻辑组件，如test<MethodUnderTest>_<state>，即testPop_emptyStack。

　　方法的定义如下：

修饰符 返回值类型 方法名(参数类型 参数名) {
   ...
   方法体
   ...
   return 返回值；
}

　　方法中包含了一个方法头和一个方法体，下面是一个方法的所有部分：

修饰符：这是可选的，即告诉编译器如何调用该方法，如public static 等。
返回值类型：方法可能会返回值。如int double等等，如果没有返回值，那么就用void。
方法名：即方法的实际名称。
参数类型：参数是可选的，方法可以不传递任何参数，但如果传递，则需要说明其类型、顺序以及参数的个数。
方法体：即具体的语句，来定义该方法的功能。

　　 java中的方法根据返回值或者参数的不同可以实现重载，如下所示：

public class Test {
    public static void main(String[] args) {
        int x1 = 2;
        int x2 = 5;
        System.out.println(add(x1, x2));

        double y1 = 1.5;
        double y2 = 2.2;
        System.out.println(add(y1, y2));
    }
    public static int add(int a, int b) {
        System.out.println("返回一个int值");
        return a + b;
    }
    public static double add(double a, double b) {
        System.out.println("返回一个double值");
        return a + b;
    }
}

　　最终的结果如下所示：

返回一个int值
7
返回一个double值
3.7

　　这样，我们就完成了java方法的重载。注意，上面函数使用public表示该方法可以被外部访问，使用static之后，如果这个方法在这个类之外被调用，可以直接Test.add调用，如果没有static修饰符，就要先创建一个Test的实例，然后通过实例来调用。

　　既然，这里讲到了方法，那么其实我们每次在写最基本的java程序的时候 public static void main 就是一个方法了，并且每次通过 "java 文件名" 来调用的时候，就是调用的这个main函数，那么如果给这个main函数传递参数呢？其实，这时只要通过命令行来传递参数就可以了，如下：

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

　　即我们在命令行中输入的就是这里的agrs，其实根据之前学的数组，可以将main函数中的参数写成（String args[]）也是可以的。

　　最终的结果如下：

十三、Java流（Stream）、文件（File）和IO

　　Java.io包括几乎所有的操作输入、输出所需要的类，所有这些类代表了输入源和输出目标，一个流可以理解为一个数据的序列，输入流表示从一个源读取数据，输出流表示向一个目标写数据，且Java为I/O提供了强大、灵活的支持，使其广泛地应用到文件传输和网络编程中。

十四、java面向对象

　　java是面向对象的，自然有继承的概念，java中使用extends表示子类继承父类，继承之后，子类拥有父类非private的属性、方法；子类也可以拥有自己的属性的方法，即子类可以对父类进行扩展；子类可以用自己的方式实现父类的方法；java可以单继承也可以多继承；

　　java中所有的类都是继承与java.lang.Object。java中，类的继承是单一继承，即一个子类只能有一个父类，即extends只能继承一个类。

　　而如果使用implements关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，如下：

public interface A {
    public voi以上是关于java重点知识的主要内容，如果未能解决你的问题，请参考以下文章 
 JAVA重点知识汇总(包含Java基础JVMJava并发)
 JAVA重点知识汇总(包含Java基础JVMJava并发)
 JAVA重点知识汇总(包含Java基础JVMJava并发)
 java重点知识
 Java重点之小白解析--浅谈HashMap与HashTable
 android小知识点代码片段