JAVA学习笔记

作者: Darkmoss | 来源:发表于2017-10-25 17:03 被阅读0次

基础篇

final 修饰符——修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
long 类型数据需在数值后加L
变量区分
类变量（静态变量）：static 修饰，独立于方法之外（静态存储区）
实例变量：无static 修饰，独立于方法之外
局部变量：类方法变量（在栈上分配）

public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
    public void method(){
        int i =0;  // 局部变量
    }
}

变量生命周期
类变量(静态变量)：程序启动是创建，程序销毁时销毁；
实例变量(全局变量)：类创建时创建，类销毁时销毁；
局部变量：方法调用时创建，方法结束时销毁。
访问控制

修饰符	当前类	同一包内	子孙类	其他包
public	Y	Y	Y	Y
protected	Y	Y	Y	N
default	Y	Y	N	N
private	Y	N	N	N

abstract 修饰符
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。如果第一行中缓冲区的 active 值被使用，那么在第二行的 active 值为 false 时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。

String、StringBuffer和StringBuilder区别
String 长度大小不可变
StringBuffer 和 StringBuilder 长度可变
StringBuilder是非线程安全的（不能同步访问）
StringBuilder相对于StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
可变参数
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号(...) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class VarargsDemo {
    public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

finalize()方法
在对象被垃圾收集器析构(回收)之前调用，用来清除回收对象。
输入输出流

iostream.png

Scannerl类
获取用户输入，通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext 与 hasNextLine 判断是否还有输入的数据。
12.1 使用 next 方法

import java.util.Scanner; 
public class ScannerDemo {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in); 
    // 从键盘接收数据  
    //next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if(scan.hasNext()){   
          String str1 = scan.next();
          System.out.println("输入的数据为："+str1);  
        }  
    }  
}

12.2 使用 nextLine 方法

import java.util.Scanner; 
 
public class ScannerDemo {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in); 
    // 从键盘接收数据  
 
    //nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if(scan.hasNextLine()){   
          String str2 = scan.nextLine();
          System.out.println("输入的数据为："+str2);  
        }  
 
    }  
}

12.3 next()和nextLine()区别
next()
(1) 一定要读取到有效字符后才可以结束输入。
(2) 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
(3) 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
(4) next() 不能得到带有空格的字符串。
nextLine()：
(1) 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
(2) 可以获得空白。

异常处理

Exception.jpg
Exception2.png

所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
Java内置异常类
14.1 非检查性异常（不处理编译可以通过，如果有抛出直接抛到控制台）

非检查性异常.png

14.2 检查性异常（不处理编译不能通过）

检查性异常.png
finally关键字
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
throw跟throws的区别

public void test thorws Exception(){
    throw new Exception();
}

throws表示一个方法声明可能抛出一个异常，throw表示此处抛出一个已定义的异常（可以是自定义需继承Exception，也可以是java自己给出的异常类）。

继承
子类拥有父类非private的属性，方法。
Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
继承关键字
extends和implements关键字
18.1 extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
public class Penguin  extends  Animal{ 
}

18.2 implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
public interface B {
    public void show();
}
public class C implements A,B {
}

super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

继承之构造器
子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会调用 super()，即自动调用父类的无参构造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
class SubClass extends SuperClass{
  private int n;
  SubClass(){
    super(300);
    System.out.println("SubClass");
  }  
  public SubClass(int n){
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    SubClass sc = new SubClass();
    SubClass sc2 = new SubClass(200); 
  }
}

输出结果为：

SuperClass(int n)
SubClass
SuperClass()
SubClass(int n):200

重写(Override)与重载(Overload)
21.1 重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
21.1.1 重写规则
（1）声明为final的方法不能被重写。
（2）声明为static的方法不能被重写，但是能够被再次声明。
（3）子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
（4）子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
（5）构造方法不能被重写。
（6）如果不能继承一个方法，则不能重写这个方法。
21.2 重载
重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
最常用的地方就是构造器的重载。
21.2.1 重载规则
（1）被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
（2）被重载的方法可以改变返回类型；
（3）被重载的方法可以改变访问修饰符；
（4）被重载的方法可以声明新的或更广的检查异常；
（5）方法能够在同一个类中或者在一个子类中被重载。
（6）无法以返回值类型作为重载函数的区分标准。
21.3 重写与重载之间的区别

overriding and overloading .png

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

多态实现方式
重写、接口、抽象类和抽象方法
抽象类和抽象方法
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
声明抽象方法会造成以下两个结果：
（1）如果一个类包含抽象方法，那么该类必须是抽象类。
（2）任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
接口
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
抽象类和接口的区别
（1）抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
（2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
（3）接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
（4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。
集合框架体系

collection.png

泛型
<? extends T>表示该通配符所代表的类型是T类型的子类。
<? super T>表示该通配符所代表的类型是T类型的父类。

public class GenericTest { 
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();    
        name.add("icon");
        age.add(18);
        number.add(314);
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
       
   }
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错。
28 多线程
一个线程的生命周期

java-thread.jpg

新建状态:

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态:

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态:

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态:

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态:

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程创建
（1）实现Runnable接口
（2）继承Thread类
（3）通过Callable和Future创建线程
创建线程的三种方式的对比：
（1）采用实现 Runnable、Callable 接口的方式创见多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
（2）使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

JAVA学习笔记

基础篇

新建状态:

就绪状态:

运行状态:

阻塞状态:

死亡状态:

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读