【Java】Java入门学习总结（一）

这几天学习入门学习Java总结，内容参考了https://www.runoob.com/java/java-tutorial.html。

Java历史

Java是1991年由Sun Microsystems公司的James Gosling和他的同事创造，最初名为“Oak”，1995年更名为Java，所以很多人说起Java的诞生，都是从1995年开始（Oracle于2010年收购了Sun Microsystems）。Java最大的一个特点是跨平台。

Java基础概念

JDK、JRE、JVM

JDK(Jave Development Toolkit)：包含JVM、一些java工具和基础类库。

JRE(Jave Runtime Environment)：是运行Java应用程序所必须的环境集合，包含了JVM实现和Java核心类库支持文件，如果仅仅需要运行java程序，只需要安装JRE。

JVM(Jave Virtual Machine)。

javac和java命令

javac和java命令的区别：javac将.java的源代码编译成.class的字节码文件，java调用JVM执行.class文件。

例如：执行javac HelloWorld.java命令编译成字节码HelloWorld.class；执行java HelloWorld命令运行字节码文件（java命令后面是java类名，不要将“.class”、“.java”加到后面）

JDK版本

目前主要稳定的长期版本是JDK11。

openjdk和hotspot是什么区别呢？

https://mirrors.tuna.tsinghua.edu.cn/AdoptOpenJDK/8/

JAVA的集成开发环境IntelliJ IDEA。

Java平台的版本划分。

Java发展至今，按应用范围划分为3个版本，即Java SE、Java EE和Java ME。

Java SE(Java Platform Standard Edition)

Java SE是Java的标准版，是Java的基础，它包含了Java语言基础、I/O(输入/出)、网络通信(Socket)、多线程以及JDBC(Java数据库连接)操作和GUI编程等，并且Java SE为Java EE提供了基础以支持Java Web服务的开发。

Java EE(Java Platform Enterprise Edition) /Jakarta EE

Java EE是Java的企业级应用程序版本。Java EE是在Java SE的基础上构建的，能够帮助人们开发和部署服务器端Java应用程序。2017年，Oracle公司将Java EE移交给开源组织 Eclipse软件基金会，2018年Eelipse将Java EE改名为“Jakarta EE”。目前Java EE (Jakarta EE)由开源社区进行维护。

Java ME(Java Platform Micro Edition)

Java ME为在移动设备和嵌入式设备(如手机、电视机顶盒等)上运行的应用程序提供环境。目前Java ME已经不常使用，在Google的Android系统问世后，绝大部分移动设备使用了Android系统，Android系统中的应用程序基于Java SE而不是Java ME。

Java语言是否跨平台

Java语言是跨平台的编程语言，这里说的平台指的是计算机中的CPU和操作系统的整体。CPU种类繁多，不同类型的CPU使用不同的指令集，不同的操作系统支持不同的指令集。因为目前主流的操作系统支持大部分主流的CPU全部指令集，所以在操作系统层面上就屏蔽了CPU种类的不同，但是操作系统根据CPU中通用寄存器的宽度也分成了32位和64位，所以目前说的Java语言跨平台指的是跨操作系统版本。

如何实现Java跨平台

Java是利用JVM(Java虚拟机)实现跨平台的。Java源代码(“.java”)经过Java编译器编译成 Java字节码(“.class”)，执行Java字节码时，Java字节经过JVM解释为具体平台的具体指令并执行。不同平台有不同的JVM，主流平台都提供了JVM，所以Java字节码可以在主流平台上解释执行。在这个意义上Java是跨平台的，也就是说，Java的字节码是跨平台的。

Java基础

Java基本数据类型

Java变量类型

Java修饰符

Java面向对象

类的继承

类的继承格式

class supercalss {
}
 
class subclass extends superclass {
}

Java不支持多继承，但支持多重继承，如B继承A，C继承B。不同类可以继承同一个类。

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字

extends关键字

extends 关键字只能继承一个类。

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();
  }
}
/*
输出结果：
animal : eat
dog : eat
animal : eat
*/

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final。

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 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); 
  }
}

/*
输出：
------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200
*/

类的多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

多态实现的方式

1. 重写：子类重写父类。

2. 接口：java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。

3. 抽象类和抽象方法

重写(Overriding)和重载(Overloading)

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

• 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• 方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• 方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。要想调用父类中被重写的方法，则必须使用关键字 super。

重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。

重载和重写的区别：

多态存在的三个必要条件

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

例子：

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中没有虚函数

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

抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

在 Java 语言中使用 abstract class 来定义抽象类：

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
}

抽象类不能被实例化，否则会报错。

抽象方法的定义：

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public abstract double computePay();
   
   //其余代码
}

• 如果一个类包含抽象方法，那么该类必须是抽象类。
• 任何子类必须重写父类的抽象方法，否则需要声明自身为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

总结：

• 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
• 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
• 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
• 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
• 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

类的封装

封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

实现封装的过程：

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
    private String name;
    private int age;
}

​ 这段代码中，将 name 和 age 属性设置为私有的，只能本类才 能访问，其他类都访问不了，如此就对信息进行了隐藏。

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{    
	private String name;    
	private int age;    
	public int getAge(){      
		return age;    
	}    
	public String getName(){      
		return name;    
	}    
	public void setAge(int age){      
		this.age = age;    
	}    
	public void setName(String name){      
		this.name = name;    
	}
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。实例中public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

Java接口

接口的申明

接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。申明格式如下：

[可见度] interface 接口名称 [extends 其他的接口名] {        
	// 声明变量        
	// 抽象方法
}

简单例子：

/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包 
public interface NameOfInterface {   
	//任何类型 final, static 字段   
	//抽象方法
}

接口和类很像，具有很多和类一样的特征，可以认为接口是一种特殊的类。接口中申明了一系列变量和方法，方法时抽象的，没有方法体。

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final变量（并且只能是 public，用 private 修饰会报编译错误）。

接口的继承

一个接口能继承另一个接口，使用extends关键字，子接口继承父接口的方法。在Java中，类的多继承是不合法，但接口允许多继承。在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。

public interface Hockey extends Sports, Event

接口的实现

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。语法格式：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

在实现接口的时候，也要注意一些规则：

• 一个类可以同时实现多个接口。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口，这和类之间的继承比较相似。

重写接口中声明的方法时，需要注意以下规则：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

标记接口

标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

例如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util;public interface EventListener {}

标记接口主要用于以下两种目的：

1. 建立一个公共的父接口：正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
2. 向一个类添加数据类型：这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

枚举类

定义

Java 枚举是一个特殊的类，一般表示一组常量。使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

enum Color {     
	RED, GREEN, BLUE; 
} 

每个枚举都是通过 Class 在内部实现的，且所有的枚举值都是 public static final 的。以上的枚举类 Color 转化在内部类实现：

class Color {     
	public static final Color RED = new Color();     
	public static final Color BLUE = new Color();     
	public static final Color GREEN = new Color();
}

values(), ordinal() 和 valueOf() 方法

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

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