Java基础

参考：《Java程序设计实用教程》与B站“综合宅散司机”java教程

JDK：Java Development Kit（java开发工具包）

Java开发工具包，包含JRE。面向开发人员。

JRE：Java Runtime Environment（Java运行环境）

包含了JVM，runtime class libraries和Java application launcher，运行Java程序的必要组件，不含开发工具。面向使用人员。

1. 基础语法

1.1. 标识符与关键字

标识符：字母，数字，下划线“_”，美元符号$。（首字符不能带数字）

Java命名约定：

1. 类和接口名：由若干名词组成，首字母大写。MyClass, JHelloWorld
2. 方法名：由若干名词组成，首字符小写，其余单词大写，尽量少用下划线。setName, getAge
3. 常量名：由若干名词组成，全部使用大写字母，词与词之间下划线分割。HIGH_NAME
4. 变量名：由若干名词组成，首字符用小写字母，其余单词首字母大写。authorName, timeSleep

1.2. 基本数据类型的强弱关系

位：bit(b) 计算机最小数据单位 ；字节： byte（B）存储空间的基本计量单位； 1Byte=8bit。

基本数据类型

类型	内容	默认值	位数	取值范围
boolean	true/false	false	8	true/false
char	Unicode	\u0000	16	\u0000~\uFFFF(0~65535)
byte	整数	0	8	-128~+127
short	整数	0	16	-32768~+32768
int	整数	0	32	-2147483648~+2147483647
long	整数	0L	64	-9223372036854775808~+9223372036854775807
float	浮点	0.0f	32	3.402823e+38 ~ 1.401298e-45
double	浮点	0.0d	64	1.797693e+308~ 4.9000000e-324

byte < short & char < int < long < float < double

Java中String是一个对象，引用类型。基础类型只表示简单的字符或者数字，引用类型可以是任何复杂的数据结构。

1.3. 类和对象

Java文件命名两条原则：一个Java文件最多只能包含一个公共类，Java文件要求与其内部的公共类同名。

类的定义：[<修饰符>]class<类名>[extends<超类名>][implements<接口名>]   public class xxx

类是同种对象的集合和抽象。

成员变量：[<修饰符>]<变量类型><变量名>    double length

类的数据，反映了对象的属性和状态。

 成员方法：[<修饰符>]<返回类型><方法名>（[<参数列表>]）[throws<异常类>]  {方法体}    double area()

类的行为，实现了对数据的操作，反映了对象的功能。

构造方法：[<修饰符>]<类名>（[<参数列表>]）{方法体} 类名即构造方法名 public JVar()（实例化对象时，会调用构造方法）

用于创建类的实例并对实例变量进行初始化。

构造方法通过new运算符调用，成员方法通过对象调用。

实例化格式：<类名><对象名>=new<构造方法名/类名>（参数） JStudent s = new JStudent(）

用于初始化新建对象，被实例化时，最先执行的就是构造函数。

成员变量的引用格式：引用对象名.变量名

成员变量在类中方法外面，局部变量在方法或者代码块中，或者方法声明上。

成员方法的调用格式：引用对象名.方法名（[实际参数列表]）

this关键字：用于引用全局变量来解决可能在全局变量与局部变量之间发生的同名冲突。(this代表调用这个函数的对象)

final关键字：用于修饰类（无法被继承），类属性（无法被修改）和类方法（无法被覆盖）。

static关键字：修饰类的成员，所有静态变量统一存储在内存的静态存储区。可以直接被类名调用。

静态变量所属于类，称为类变量，存储于方法区中的静态区，可以被类或者对象调用。

成员变量所属于对象，称为实例变量，存储于堆内存的对象中，只能被对象调用。 

静态方法：只能访问静态成员，非静态的方法可以访问静态与非静态。静态方法中不可以出现this,super关键字。方法中如果没有调用过非静态的内容，该方法就静态化。

静态代码块：用来给类进行初始化。

构造代码块：给所有对象初始化。

单例设计模式：

class Single
{
    private static Single s = new Single(); 
    private Single() {}    
    public Single getInstance() { return s;}
}

1.4. 类的封装性，继承性，多态性以及接口

封装性：限制类的外部成员对内部成员进行访问，便于程序功能的拓展和维护。

继承性：复用程序代码。(final修饰的类无法被继承，final修饰的方法无法被覆盖)

多态性：同名的若干方法具备不同的实现。有良好的扩展性。

可见度	private	default	protected	public
同一个类中	允许访问	允许访问	允许访问	允许访问
同一个包中		允许访问	允许访问	允许访问
不同包的子类			允许访问	允许访问
不同包的非子类				允许访问

extends关键字：[<修饰符>]class<子类名>extends<父类名> {子类名} 

被继承的类叫父类或超类（superclass），继承父类的类叫子类（subclass）。子类继承了父类所有成员变量和方法，继承关系可以传递。若子类成员变量或方法与父类重名，则覆盖父类变量或方法。

super关键字：super.<成员变量> / super.<成员方法> / super(调用参数列表)

表示对某个类的父类的引用。（成员变量，成员方法，构造方法）

创建子类对象时，先执行父类的构造方法，再执行子类的构造方法。如果子类没有使用super关键字，则系统会默认产生super()代码。若要引用父类有参构造方法，则必须用super关键字引用，同时是子类构造方法中第一条语句。

方法重载（Overloading）：静态多态性，同一个类中允许多个同名方法。

方法覆盖（Overriding）:动态多态性，子类对父类方法进行重新定义。无法覆盖私有方法以及final修饰的方法。

同一个类中，方法只能被重载，无法被覆盖。

抽象类：专门设计用来让子类继承的类，抽象方法必须被子类覆盖。

abstract class<类名> {

        abstract 返回类型 方法名 （参数列表）；

}

向上转型父类引用指向子类对象。 父类 varname = new 子类（）；

如果需要调用子类成员变量，可以使用get方法。

接口：通过interface可以指定一个接口必须做什么，而不是怎么做。//可以简单理解为一个特殊的抽象类。

定义 [public]interface接口名 [extends父接口名列表（a,b,c）] {

数据类型 变量名 = 常量值；  返回类型 方法名（参数列表）[throw 异常列表]； }

接口有继承性，只包括常量定义与抽象方法。默认接口成员变量修饰加上public,static和final。成员方法修饰加上public与abstract。

接口的实现：class <类名>  implements接口名1，接口名2，..

接口的实现即实现接口中定义的所有方法（方法覆盖）。接口把方法的特征与方法的实现分割开来。

多继承的弊端：调用不确定，因为方法主体。而接口没有方法主体，所以可以多继承。

接口回调：把变量定义成接口的对象而不是类的类型。

接口与抽象类区别
1	抽象类和类之间存在的是继承关系，只能单继承。	接口和类之间存在的是实现关系，可以多实现。
2	抽象类中是可以定义非抽象类的，提供给子类直接使用。	接口中的方法都是抽象的，子类必须全部实现才可以使用。

 

多态：某一事物的多种体现形态，可以提高代码的扩展性，但是不能使用子类特有的功能，只能使用覆盖了父类的功能。

父类或者接口的引用指向了自己的子类对象。

class Cat extends Animals {}
Animals x = new Cat(); //向上转型。隐藏具体子类型时。
Cat c = (Cat)x;//向下转型。当需要使用子类型特有的方法时。
只有子类对象在做类型变化。

class Fu
{
    int num = 4;//成员变量：在类体中定义的变量，作用范围是整个类。
    void show();//成员函数：在类体中定义的函数，作用范围是整个类。因为方法覆盖特性。
    static void show staticMethod(); //静态函数：非静态的方法可以访问类中的变量值，因此非静态方法运行时必须绑定对象（this）。静态方法也有覆盖特性，绑定类，与对象无关。
}
class Zi extends Fu
{
    int num = 5;//成员变量：多态调用时，编译和运行参考引用型变量所属类的成员变量。（看等号左边）
    void show();//成员函数：多态调用时，编译参考的是引用型变量所属的类，运行时参考的是对象所属的类。（编译看左边，运行看右边）
    static void show staticMethod(); //静态函数：静态绑定到所属类上，成员函数动态绑定到当前对象。
}
Class DuoTai
{
    public static void main(String[] args)
    {
        Fu f = new Zi();
        f.num; // 4
        f.show(); // Zi类的show()
        f.staticMethod(); //Fu类的staticMethod()
        Zi z = (Zi)f;
        z.num;// 5
        z.show(); // Zi类的show()
        z.staticMethod(); //Zi类的staticMethod()
    }
}

内部类：class里面再定义一个class。

实名内部类：内部类有显示的类名。

[类修饰词表] class 类名 [extends 父类名] [implements接口名列表] { 类体 }

创建静态实名内部类： new 外部类名.实名内部类名（构造方法调用参数列表） 

访问静态属性成员格式：外部类名.实名内部类.静态成员

创建无静态属性的实名内部类：外部类实例对象.new 实名内部类名（构造方法调用参数列表）/ new 外部类名.new 实名内部类（构造方法调用参数列表）

访问不具有静态属性成员格式：实名内部类实例对象.成员

局部内部类：内部类定义在局部位置上。

匿名内部类：new 父类名（父类型的构造方法的调用参数列表）{ 类体 } //前提是内部类必须继承一个类或者实现接口。（内部类的简化格式）

abstract class AbsDemo
{
    abstract void show();
}
class Outer
{
    class Inner_1 {} //可以被成员修饰符修饰，非静态内部类无法定义静态方法，只能定义静态常量（static final）。
    static class Inner_2 {}
    void method()
    {
        class Inner_3 {} //局部内
/*匿名内部类，简化版的子类对象
        new AbsDemo()
        {    
            void show() {} 
        }.show();
*/
    }   
}
class InnerClass
{
    public static void main(String[] args)
    {
        Outer.Inner_1 in1 = new Outer().new Inner_1(); //创建内部类对象
        Outer.Inner_2 in2 = new Outer.Inner_2();
    }
}

API：application programming interface

Object类：是所有类的父类。

equals()与==： ==是判断2个变量或实例是不是指向同一个内存空间。equals是判断2个变量或实例所指向的内存空间的值是不是想等。即==是判断是不是同一个东西，equals判断是不是相同。

 

1.4. 异常

异常：java运行时发生不正常的问题。

Exception：jvm发生的。（Java Virtual Machine）

Error：由系统底层发生的。

异常处理方式：

1. 不进行具体处理，抛给调用者。即在函数上通过throw关键字声明异常，告诉调用者。

2. 针对性处理方式：捕获。

class ExceptionDemo 
{
    int errorDemo() throws Exception //声明异常
    {
        throw new Exception(""); //抛出异常
    }
}
try {}
catch (异常类 变量){}
finally {}

 

1.5. 多线程

进程：运行中的程序。

多进程：在操作系统中同时运行多个任务（程序）。

线程（Thread）：进程中某个单一顺序的控制流，也被称为轻量进程。

多线程：在同一应用程序中有多个顺序流同时执行。

多线程实现方式：

1. 继承Thread类

覆写run()方法。局限性：一个类只能继承一个父类。

2. 实现Runnable接口