java核心基础教程

java核心基础教程，这是自己之前学习java做开发的时候，记录的笔记，供大家学习！

关键字

• 一个源文件中只能有一个 public 类
• 一个源文件可以有多个非 public 类
• 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
  

java常量

final double PI = 3.1415927;

static 修饰符

静态变量

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

• 静态方法：
  static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
  final关键字
  被 final 修饰的实例变量必须显式指定初始值。
  final 修饰符通常和 static 修饰符一起使用来创建类常量。
  父类中的 final 方法可以被子类继承，但是不能被子类重写。
  final 类不能被继承，没有类能够继承 final 类的任何特性

abstract 修饰符

抽象类：空壳类
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
抽象类可以包含抽象方法和非抽象方法。
对方法进行申明，不需要写方法体

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法
抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。

synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问
synchronized 修饰符可以应用于四个访问修饰符
public synchronized void showDetails(){
.......
}

三目运算符

(a == 1) ? 20 : 30;，前者是条件判断，后面是条件判断的结果

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
String name = “James”;
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

Java 增强 for 循环

for(声明语句 : 表达式)
{
//代码句子
}

continue 关键字

跳过当前循环，继续执行下一循环

extends关键字

类的继承，extends关键字是单继承，一个子类只能继承拥有一个父类d

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口

super 与 this 关键字

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

void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // 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;
  }
}

// SubClass 类继承

class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器

    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器

    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}

// SubClass2 类继承

class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器

    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器

    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

Java Number & Math 类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

Java StringBuffer 和 StringBuilder 类

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StriingBuffer是线程安全的，后者是线程不安全的

For-Each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：

for(type element: array)
{
    System.out.println(element);
}

使用 SimpleDateFormat 格式化日期

  Date dNow = new Date( );
  SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");、
  System.out.println("当前时间为: " + ft.format(dNow));

方法的重载

重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

变量作用域
变量的范围是程序中该变量可以被引用的部分。
方法内定义的变量被称为局部变量。
局部变量的作用范围从声明开始，直到包含它的块结束。
局部变量必须声明才可以使用。
方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
for循环的初始化部分声明的变量，其作用范围在整个循环。
但循环体内声明的变量其适用范围是从它声明到循环体结束。

可变参数：typeName… parameterName
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

finalize() 方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

protected void finalize()
{
   // 在这里终结代码
关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
}

关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。

Java 流(Stream)、文件(File)和IO

输入输出没有掌握
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java 的控制台输入由 System.in 完成。

控制台读取或者写入数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedReader 对象创建后，我们便可以使用 read() 方法从控制台读取一个字符，或者用 readLine() 方法读取一个字符串。

import java.io.*;
 //BufferedReader缓冲流
public class BRReadLines {
    public static void main(String[] args) throws IOException {
        // 使用 System.in 创建 BufferedReader
        //创建一个输入缓冲流对象
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        System.out.println("Enter lines of text.");
        System.out.println("Enter 'end' to quit.");
        do {
            str = br.readLine();//单字符使用br.read()
            System.out.println(str);
        } while (!str.equals("end"));
    }
}

//创建字符输出流数据
//创建一个输出缓冲流对象
BufferedReader bw = new BufferedReader(new 
OutputStreamWriter(System.out));
bw.write("")

字节流

FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。

File f = new File("C:/java/hello");
InputStream in = new FileInputStream(f);

File f = new File("C:/java/hello");
OutputStream fOut = new FileOutputStream(f);
os.write(bWrite[x]); //将数据写入文件中

在这里插入图片描述

Java Scanner 类

Scanner s = new Scanner(System.in);
方法的重写规则
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
访问权限不能比父类中被重写的方法的访问权限更低。

• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 构造方法不能被重写。
• 如果不能继承一个类，则不能重写该类的方法。

Java 多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作
多态性是对象多种表现形式的体现。

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

class Shape {
    void draw() {}
} 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法

      show(new Dog());  // 以 Dog 对象调用 show 方法

                
      Animal a = new Cat();  // 向上转型  

      a.eat();               // 调用的是 Cat 的 eat

      Cat c = (Cat)a;        // 向下转型  

      c.work();        // 调用的是 Cat 的 work

  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断

        if (a instanceof Cat)  {  // 猫做的事情 

            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 

            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

虚函数

虚函数的存在是为了多态。
Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

ava 枚举(enum)
Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一年的 12 个月份，一个星期的 7 天，方向有东南西北等。
Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。
例如定义一个颜色的枚举类。

enum Color 
{ 
    RED, GREEN, BLUE; 
} 
 Color myVar = Color.BLUE;

以上枚举类 Color 颜色常量有 RED, GREEN, BLUE，分别表示红色，绿色，蓝色。
values(), ordinal() 和 valueOf() 方法
enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。
values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

• values() 返回枚举类中所有的值。
• ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
• valueOf()方法返回指定字符串值的枚举常量。

java数据结构

LinkedList

该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：
List list=Collections.synchronizedList(newLinkedList(…));
LinkedList 查找效率低。

ArrayList

该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。

HashSet
该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。

TreeSet
该类实现了Set接口，可以实现排序等功能。

HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。

TreeMap
继承了AbstractMap，并且使用一颗树。

Hashtable
Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。

arrayList遍历

  //第三种遍历 使用迭代器进行相关遍历

 Iterator<String> ite=list.iterator();
 while(ite.hasNext())//判断下一个元素之后有值
 {
     System.out.println(ite.next());
 }

map遍历

  //第一种：普遍使用，二次取值
  //增强for循环
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
   //第四种
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }    

ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。
如果我们要存储其他类型，而 只能为引用数据类型，这时我们就需要使用到基本类型的包装类。
ArrayList 排序
Collections.sort(sites); // 字母排序

Java ArrayList 方法

Java ArrayList 常用方法列表如下：

LinkedList sites = new LinkedList();
sites.add(“Google”);
sites.add(“Runoob”);
sites.add(“Taobao”);
sites.add(“Weibo”);
System.out.println(sites);

 // 使用 addFirst() 在头部添加元素
sites.addFirst("Wiki");

    // 使用 addLast() 在尾部添加元素
sites.addLast("Wiki");
System.out.println(sites);


 // 使用 removeFirst() 移除头部元素
sites.removeFirst();
System.out.println(sites);

  // 使用 removeLast() 移除尾部元素
sites.removeLast();
System.out.println(sites);

 // 使用 getFirst() 获取头部元素
System.out.println(sites.getFirst());

 System.out.println(sites.getLast());

Java HashSet

Java 集合框架

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。
HashSet 允许有 null 值。
HashSet 是无序的，即不会记录插入的顺序。
HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。
HashSet 实现了 Set 接口。

HashSet<String> sites = new HashSet<String>();

        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));
        
         sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
//删除所有的元素
         sites.clear();    
          System.out.println(sites.size());  
        迭代 HashSet
            for (String i : sites) {
            System.out.println(i);
        }  
           

Java HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。
HashMap 是无序的，即不会记录插入的顺序。

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

 Sites.put(1, "Google");
 System.out.println(Sites.get(3));
 Sites.remove(4);//通过键删除元素
 System.out.println(Sites.size());
 
      //迭代输出 key 和 value
        for (Integer i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
        // 返回所有 value 值
        for(String value: Sites.values()) {
          // 输出每一个value
          System.out.print(value + ", ");
        }

迭代器接口定义了几个方法，最常用的是以下三个：

• next()
• 返回迭代器的下一个元素，并将迭代器的指针移到下一个位置。
• hasNext()
• 用于判断集合中是否还有下一个元素可以访问。
• remove()
• 从集合中删除迭代器最后访问的元素（可选操作）。

   // 创建集合
    ArrayList<String> sites = new ArrayList<String>();
    // 获取迭代器
    Iterator<String> it = sites.iterator();

Java URL 处理

URL（Uniform Resource Locator）中文名为统一资源定位符，有时也被俗称为网页地址。表示为互联网上的资源，如网页或者 FTP 地址。
本章节我们将介绍 Java 是如何处理 URL 的。URL 可以分为如下几个部分。
protocol://host:port/path?query#fragment
protocol(协议)可以是 HTTP、HTTPS、FTP 和 File，port 为端口号，path为文件路径及文件名。
HTTP 协议的 URL 实例如下:
http://www.runoob.com/index.html?language=cn#j2se
URL 解析：

• 协议为(protocol)：
• 主机为(host:port)
• 端口号为(port):
• 文件路径为(path)：
• 请求参数(query)
• 定位位置(fragment)：
  
  序号方法描述
  1public String getPath()返回URL路径部分。
  2public String getQuery()返回URL查询部分。
  3public String getAuthority()获取此 URL 的授权部分。
  4public int getPort()返回URL端口部分
  5public int getDefaultPort()返回协议的默认端口号。
  6public String getProtocol()返回URL的协议
  7public String getHost()返回URL的主机
  8public String getFile()返回URL文件名部分
  9public String getRef()获取此 URL 的锚点（也称为"引用"）。
  10public URLConnection openConnection() throws IOException打开一个URL连接，并运行客户端访问资源。