Java 学习总结

时间 2019-11-09

标签 java 学习总结栏目 Java 繁體版

原文原文链接

Start：java

每一个 Java 程序至少应该有一个类，一般类名的第一个字母大写。数组

若要使用数学方法须要用到 Math 类。随机方法也在该类中。并发

一样程序也是从 main 方法开始执行的。ide

然而 Java 的加号 + ，不只能够用于数值之间，字符串之间，还能够用于数值和字符串之间。ui

Java 容许两个字符相加，例如：int i = 'a' + 'b';this

只是字符串常量不能够跨行。url

Java 的输入和输出：spa

输出: System.out.print("string") 不换行，或者 Sytem.out.println("string") 换行。.net

输入: 输入要稍微麻烦一些，须要导入 java.util.Scanner。如：import java.util.Scanner命令行

能够用 Scanner 类建立它的对象，来读取 System.in 的输入。

例如：Scanner input = new Scanner(System.in)。

从键盘读取各类数据类型，例如：

byte byteValue = input.nextByte();

short shortValue = input.nextShort();

int intValue = input.nextInt();

long longValue = input.nextLong();

float floatValue = input.nextFloat();

double doubleValue = input.nextDouble();

String string = input.next(); 这种读取方式以碰到空格就结束。

String string = input.nextLine(); 这种读取方式以碰到换行结束。

Java 提供了boolean 数据类型：表示 false 或 true。

Java 还有字符串的数据类型，例如：String message = "Welcome to java";

String 对象也有许多简单的字符串操做方法。

标识符：

标识符是由字母，数字，下划线 _ ，或美圆符号 $ 构成的字符序列，不能以数字开头。

命名常量：final 数据类型数据名称 = 常量值。

例如： final double PI = 3.1415926;

命名习惯：

使用小写字母命名变量和方法，若是一个名字包含多个单词，就把他们连起来，

第一个单词的字母小写，后面的每一个单词首字母大写，例如：blackCat。

类名中的每一个单词首字母大写，例如 ComputerScience。

大写常量中的全部字母，多个单词间用下划线链接，例如：MAX_VALUE。

为了提升程序可读性，java 容许在数值直接量的两个数字之间使用下划线。例如：1000_000_000。

方法：

定义方法：修饰符返回值类型方法名(参数列表) { ...... }

例如：public static int max(int a,int b) {......}

数组：

声明数组：元素类型[ ] 数组变量名; 元素类型[ ][ ] 数组变量名;

建立数组：new 元素类型[数组大小] ; new 元素类型[数组大小][数组大小];

也能够一块儿使用，例如：int[ ] ary = new int[10]; double[ ][ ] array = new double[10][10];

数组的大小，例如：ary.length。array.length;

为数组设计的循环 forecah：

语法为：for(元素类型元素名称 : 数组名) { ......}

例如：for(int e : ary) { System.out.println(e) };

数组复制：

除了能够用循环来复制外，Java 提供了一些方法来复制数组。

例如使用 java.lang.System 类的 arraycopy 方法来复制数组，语法为：System.arraycopy(sourceArray,srcPos,targetArray,tarPos,length);

注意：该方法没有遵循命名习惯。

另外，java.util.Arrays 类中有许多常见的数组操做方法，好比查找，排序等等。

数组值交换例子：

public static void main(String[] args)
        {
            int[] a = {1,2};
            swap(a[0],a[1]);
            System.out.printf("%d, %d\n",a[0],a[1]);
            swapArray(a);
            System.out.printf("%d, %d\n",a[0],a[1]);
        }
        
        public static void swap(int m,int n)
        {
            int temp = n;
            n = m;
            m = temp;
        }
        
        public static void swapArray(int[] array)
        {
            int temp = array[0];
            array[0] = array[1];
            array[1] = temp;
        }

运行结果为：1，2 2，1。这是由于数组的引用传递给了方法。

命令行参数：

或许你已经注意到 main 方法的声明不同凡响，它具备 String[ ] 类型参数 args。

很明显 args 是一个字符串类型数组，所以能够给它传递参数。

例如：

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

可经过 java 命令来运行该程序，例如：java display 1 2 3。

可变长度参数列表：

方法中的参数声明：(类型名... 参数名) 注意：类型名后紧跟着省略号。

例如：public static int max(int... numbers) { ...... }

对象和类：

包含 main 方法的类称为主类。

访问对象的数据和方法：

在建立一个对象后，它的数据和方法可使用点操做符 ( . ) 来访问和调用，该操做符也称为对象成员访问操做符。

若是一个引用类型的数据域没有引用任何对象，那么这个数据域就有一个特殊的 Java 值 null。

引用类型数据域的默认值是 null，数值类型数据域的默认值是 0，boolean 类型数据域的默认值是 false，

而 char类型数据域的默认值是 '\u0000'。可是，Java 没有给方法中的局部变置陚默认值。

静态变量，常量和方法：

静态变量被类中全部对象所共享，静态方法不能访问类中的实例成员。、

实例方法便可访问静态变量或方法，也能够访问实例变量或方法。

可见性修饰符：

可见性修饰符能够用于肯定一个类以及它的成员的可见性。

能够在类、方法和数据域前使用 public 修饰符，表示它们能够被任何其余的类访问。

若是没有使用可见性修饰符，那么则默认类、方法和数据域是能够被同一个包中的任何一个类访问的。

这称做包私有 (package-private) 或包内访问 (package-access)。

除了 public 和默承认见性修饰符，Java 还为类成员提供 private 和 protected 修饰符。

private 修饰符：限定方法和数据域只能在它本身的类中被访问。

修钸符 private 只能应用在类的成员上。

修饰符 public 能够应用在类或类的成员上。

在局部变量上使用修饰符 public 和 private 都会致使编译構误。

为防止數据被篡改以及使类更易于维护，最好将数据域声明为私有的。

向方法传递对象参数：

能够将对象传递给方法。同传递数组同样，传递对象其实是传递对象的引用。

this 引用：

关键字 this 引用对象自身。它也能够在构造方法内部用于调用同一个类的其余构造方法。

this 关键字能够用于引用类的隐藏數据域。隐藏的静态变量能够简单地经过 “类名 .静态变量” 的方式引用。

隐藏的实例变量就须要使用关键字 this 来引用。

使用 this 调用构造方法：
Java 要求在构造方法中，语句 this( 参数列表）应在任何其余可执行语句以前出现。

若是一个类有多个构造方法，最好尽量使用 this(参数列表) 实现它们。

一般，无参數或参数少的构造方法能够用 this(参数列表) 调用参数多的构造方法。

String 类：

String 对象是不可改变的。字符串一旦建立，内容不能再改变。

例如：String message = "Welcome to Java";

message = "Hello world!";

开始 message 引用字符串"Welcome to Java"，以后 message 引用字符串"Hello world"。

"Welcome to Java"字符串并无改变，只是不能够再引用了。

另外，String 对象之间的比较，比较的是对象不是内容。

例如：String s1 = "Welcome to Java";

String s2 = new String("Welcome to Java");

String s3 = "Welcome to Java";

此时，s1 == s3，s1 != s2。

另外，该类提供了许多方法，能够本身查阅。

StringBuilder类和 StringBuffer类：

StringBuilder 和 StringBuffer 相似于 String 类，区别在于 String 类是不可改变的。

— 般来讲，只要使用字符串的地方，均可以使用StringBuilder/StringBuffer类。

StringBuilder/StringBuffer 类比 String类更灵活。

除了 StringBuffer 中修改缓冲区的方法是同步的，StringBuilder 类与 StringBuffer 类是很类似的。

若是是多任务并发访问，就使用StringBuffer, 由于这种状况下须要同步以防止 StringBuffer 崩溃。

而若是是单任务访问，使用StringBuilder 会更有效。

一样，该两个类也提供了许多修改字符串的方法。

继承和多态：

修饰符(public,private,protected) class 类名 extends 要扩展的类名 { ...... }

这样就完成了继承。若要初始要扩展类名里的私有属性，须要调用要扩展类名的初始话私有属性的方法。

不能够用 this 指针来初始化。

关键字 super：

关键字 super 指代父类，能够用于调用父类中的普通方法和构造方法。

关键字 super 是指这个 super 关键字所在的类的父类。

关键字 super 能够用于两种途径：

1) 调用父类的构造方法。

2) 调用父类的方法。

之因此引入该关键字，是由于父类的构造方法不会被子类继承。

调用父类构造方法的语法是：super() 或者 super(parameters)

语句 super() 调用父类的无参构造方法，而语句 super(parameters) 调用与参数匹配的父类的构造方法。

语句 super() 和 super(parameters) 必须出如今子类构造方法的第一行，这是显式调用父类构造方法的惟一方式。

构造方法链：

构造方法能够调用重载的构造方法或父类的构造方法。

若是它们都没有被显式地调用，编译器就会自动地将 super() 做为构造方法的第一条语句。

在任何状况下，构造一个类的实例时，将会调用沿着继承链的全部父类的构造方法。

当构造一个子类的对象时，子类构造方法会在完成本身的任务以前，首先调用它的父类的构造方法。

若是父类继承自其余类，那么父类构造方法又会在完成本身的任务以前，调用它自己的父类的构造方法。

这个过程持续到沿着这个继承体系结构的最后一个构造方法被调用为止。这就是构造方法链。

调用父类方法：

关键字 super 不只能够引用父类的构造方法，也能够引用父类的方法。所用语法以下：

super.方法名(参数);

方法重写：

子类从父类中继承方法。有时，子类须要修改父类中定义的方法的实现，这称做方法重写。

要重写一个方法，须要在子类中使用和父类同样的签名以及同样的返回值类型来对该方法进行定义。

方法重写与重载：

重载意味着使用一样的名字可是不一样的签名来定义多个方法。重写意味着在子类中提供一个对方法的新的实现。

例如：重写

public static void main(String[] args)
    {
        A a = new A();
        a.p(10);
        a.p(10.0);
    }

public static class B
    {
        public void p(double i)
        {
            System.out.println(i*2);
        }
    }

public static class A extends B
    {
        public void p(double i)
        {
            System.out.println(i);
        }
    }

运行结果为：10.0，10.0。

例如：重载

public static void main(String[] args)
    {
        A a = new A();
        a.p(10);
        a.p(10.0);
    }

public static class B
    {
        public void p(double i)
        {
            System.out.println(i*2);
        }
    }

public static class A extends B
    {
        public void p(int i)
        {
            System.out.println(i);
        }
    }

运行结果：10，20.0。

为了不错误，可使用一个特殊的 Java 语法，称为重写标注, 在子类的方法前面放一个 @Override。

该标注表示被标注的方法必须重写父类的一个方法。若是具备该标注的方法没有重写父类的方法，编译器将报告一个错误。

Object 类：

Java 中的全部类都继承自 java.lang.Object 类。

若是在定义一个类时没有指定继承性，那么这个类的父类就被默认为是 Object。

多态：

多态意味着父类的变量能够指向子类对象。

面向对象程序设计的三大支柱是封装、继承和多态。

继承关系使一个子类继承父类的特征，而且附加一些新特征。

子类是它的父类的特殊化，每一个子类的实例都是其父类的实例，可是反过来就不成立。

所以，总能够将子类的实例传给须要父类型的参数。

使用父类对象的地方均可以使用子类的对象。这就是一般所说的多态。

简单来讲，多态意味着父类型的变量能够引用子类型的对象。

动态绑定：

抽象的说：实例可使用声明类型或它的子类型的构造方法建立。变量的实际类型是被变量引用的对象的实际类。

假如啊：

People 类里有 goToWC() 方法吧，Man类和 Women类是继承于 People类的。

这两个类里都对 goToWC() 方法进行了改造。

例如：People boy = new Man(); 或者 People girl = new Women();

此时调用 boy 或者 girl 的 goToWC() 方法，调用的将是 Man类或 Women类里的 goToWC() 方法，而不是 People 类里的。

这就是动态绑定的意思了。

ArrayList类：

Java 提供 ArrayList类来存储不限定个数的对象。

ArrayList是一种泛型类，建立一个 ArrayLis 类对象时，能够指定一个具体的类型来替换该对象。

例如：ArrayList<String> cities = new ArrayList<String>();

或者：ArrayList<java.util.Date> dates = new ArrayList<java.util.Date>();

能够这样简化：ArrayList<String> cities = new ArrayList<>();

修饰符：

使用 private修饰符能够彻底隐藏类的成员，这样，就不能从类外直接访问它们。

不使用修饰符就表示容许同一个包里的任何类直接访问类的成员，可是其余包中的类不能够访问。

使用protected 修饰符容许任何包中的子类或同一包中的类访问类的成员。

使用 public 修饰符容许任意类访问类的成员。

修饰符 private 和 protected 只能用于类的成员。

public 修饰符和默认修饰符(也就是没有修饰符)既能够用于类的成员，也能够用于类。

子类能够重写它的父类的 protected 方法，并把它的可见性改成 public。

可是，子类不能削弱父类中定义的方法的可访问性。

例如：若是一个方法在父类中定义为 public, 在子类中也必须定义为 public。

防止扩展和重写：

一个被 final 修饰的类和方法都不能被扩展。被 final 修饰的数据域是一个常数。

有时候，可能但愿防止类扩展。在这种状况下，使用 final 修饰符代表一个类是最终的，是不能做为父类的。

修饰符 public、protected、private、static、 abstract以及 final 能够用在类和类的成员(数据和方法)上，

只有 final 修饰符还能够用在方法中的局部变量上。方法内的最终局部变量就是常量。

异常类型：

异常是对象，而对象都采用类来定义。异常的根类是 java.lang.Throwable。

例如：ArithmeticException 是除以 0 异常。更多的异常类型请本身查阅文档。

异常处理：

Java 的异常处理模型基于三种操做：声明一个异常、抛出一个异常、捕获一个异常。

捕获异常：

try
{ ...... }
catch(异常类型 异常类型的对象)
{ ...... }
catch(异常类型 异常类型的对象)
{ ...... }
catch(异常类型 异常类型的对象)
{ ...... }
.
.
.

若是 try 块中的某条语句抛出一个异常，Java 就会跳过 try块中剩余的语句，而后开始査找处理这个异常的代码的过程。

处理这个异常的代码称为异常处理器 ; 能够从当前的方法开始，沿着方法调用链，按照异常的反向传播方向找到这个处理器。

从第一个到最后一个逐个检査 catch 块，判断在 catch 块中的异常类实例是不是该异常对象的类型。

若是是，就将该异常对象陚值给所声明的变量，而后执行 catch 块中的代码。

若是没有发现异常处理器，Java 会退出这个方法，把异常传递给调用这个方法的方法，继续一样的过程来査找处理器。

若是在调用的方法链中找不处处理器，程序就会终止而且在控制台上打印出错信息。寻找处理器的过程称为捕获异常。

声明异常：

Java 解释器调用 main 方法开始执行一个程序。每一个方法都必须声明它可能抛出的必检异常的类型，这称为声明异常。

为了在方法中声明一个异常，就要在方法头中使用关键字 throws。

例如：public void myMethod() throws ArithmeticException { ...... }

关键字 throws 代表 myMethod 方法可齙会抛出异常 ArithmeticException 。

若是方法可能会抛出多个异常，就能够在关键字 throws 后添加一个用逗号分隔的异常列表：

public void myMethod() throws ArithmeticException,IndexOutOfBoundsException,...

若是方法没有在父类中声明异常，那么就不能在子类中对其进行继承来声明异常。

抛出异常：

检测到错误的程序能够建立一个合适的异常类型的实例并抛出它，这就称为抛出异常。

假如程序发现除数为 0，就能够建立一个 ArithmeticException 实例并抛出它。

例如：ArithmeticException ex = new ArithmeticException("错误提示信息");

throw ex;

或者：throw new ArithmeticException("除数为 0 错误");

finally 字句：

不管异常是否产生，finally 子句老是会被执行的。

try
{ ...... }
catch(异常类型 异常类型的对象)
{ ...... }
catch(异常类型 异常类型的对象)
{ ...... }
catch(异常类型 异常类型的对象)
{ ...... }
.
.
.
finally
{ ...... }

在任何状况下，finally块中的代码都会执行，不论 try 块中是否出现异常或者是否被捕获。

考虑下面三种可能出现的状况：

一、若是 try 块中没有出现异常，执行 finally{ ...... }，而后执行 try 语句的下一条语句。

二、若是 try 块中有一条语句引发异常，并被 catch 块捕获，而后跳过 try 块的其余语句，执行 catch 块和 finally 子句。

执行 try语句以后的下一条语句。

三、若是 try 块中有一条语句引发异常，可是没有被任何 catch 块捕获，就会跳过 try 块中的其余语句，执行 finally 子句，

而且将异常传递给这个方法的调用者。即便在到达 finally 块以前有一个 return 语句，finally 块仍是会执行。

建立自定义异常类：

Java 提供至关多的异常类，尽可能使用它们而不要建立本身的异常类。

然而，若是进到一个不能用预约义异常类恰当描述的问题，那就能够经过派生 Exception 类或其子类，来建立本身的异常类。

File 类：

java.io.File 类有一些对文件操做的相关方法，可是不支持建立及读写文件相关的操做。

使用 Scanner 类从文件中读取文本数据，使用 PrintWriter 类向文本文件写入数据。

java.io.File 对象能够绑定一个文件。例如：java.io.File file = new java.io.File("test.txt");

使用 PrintWriter 写数据：

首先，必须为一个文本文件建立一个 PrintWriter 对象：PrintWriter output = new PrintWriter(fileName 或者 java.io.File 对象);

而后，能够调用PrinterWriter 对象上的 print、println 和 printf 方法向文件写入数据。

使用 Scanner 读数据：

Scanner input = new Scanner(fileName 或者 java.io.File 对象);

接下来就能够像从键盘读入那样读入了。

行分隔符字符串是由系统定义的，在 Windows 平台上 \r\n, 而在 UNIX 平台上是 \n。

为了获得特定平台上的行分隔符，使用 String lineSeparator = System.getProperty('line.separator");

若是从键盘输入，每行就以回车键结束，它对应于 \n 字符。

while( input.hasNext() ) { ...... } 保持循环直到到了文件末尾。

从 Web 上读取数据：

为了读取一个文件，首先要使用 java.net.URL 类的这个构造方法，为该文件建立一个 URL 对象。

例如：URL url = new URL("http://www.cnblogs.com/M-Anonymous/");

前缀 http:// 是必需的，不然将会引发 MaiformedURLException 运行错误，必须说明或处理该错误。

建立一个 URL 对象后，可使用URL 类中定义的 openStream() 方法来打开输入流和用输人流建立以下 Scanner 对象。

Scanner input = new Scanner( url.openStream() );

如今能够从输人流中读取数据了，如同从本地文件中读取同样。

例如：

    public static void main(String[] args)
    {
        System.out.println("Enter a URL: ");
        Scanner input1 = new Scanner(System.in);
        String URLString = input1.next();
        try
        {
            int count = 0;
            java.net.URL url = new java.net.URL(URLString);
            Scanner input2 = new Scanner(url.openStream());
            while(input2.hasNextLine())
            {
                String line = input2.nextLine();
                count += line.length();
            }    
            System.out.println("The file size is " + count + "characters");    
            input1.close();
            input2.close();
            
        }
        catch(java.net.MalformedURLException ex)
        {
            System.out.println("Invalid URL");
        }
        catch(java.io.IOException ex)
        {
            System.out.println("I/O Errors: no such file");
        }

    }

抽象类和接口：

抽象类不能够用于建立对象。抽象类能够包含抽象方法，这些方法将在具体的子类中实现。

抽象方法：在方法头中使用 abstract 修饰符表示。

抽象类：在类头使用 abstract 修饰符表示。

抽象类和常规类很像，可是不能使用 new 操做符建立它的实例。

抽象方法只有定义而没有实现。它的实现由子类提供。

一个包含抽象方法的类必须声明为抽象类。

抽象类的构造方法定义为 protected, 由于它只被子类使用。

建立一个具体子类的实例时，它的父类的构造方法被调用以初始化父类中定义的数据域。

抽象类的几点说明：

抽象方法不能包含在非抽象类中。若是抽象父类的子类不能实现全部的抽象方法，那么子类也必须定义为抽象的。

换句话说，在抽象类扩展的非抽象子类中，必须实现全部的抽象方法。还要注意到，抽象方法是非静态的。

抽象类是不能使用 new 操做符来初始化的。可是，仍然能够定义它的构造方法，这个构造方法在它的子类的构造方法中调用。

子类能够覆盖父类的方法并将它定义为 abstract。即便子类的父类是具体的，这个子类也能够是抽象的。

1. Java学习总结
2. java 学习总结
3. java学习总结
4. java IO流学习总结
5. Java 泛型学习总结
6. Java事务——学习总结
7. java框架学习总结
8. Java IO流学习总结
9. Java EE day03学习总结
10. Java EE day14学习总结
更多相关文章...
• XML 总结下一步学习什么呢？ - XML 教程
• 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
• Tomcat学习笔记（史上最全tomcat学习笔记）
• Kotlin学习（一）基本语法