Java学习笔记

public class HelloWorld
{
    public static void main(String[] args)  //命令行参数，若要使用需要设置其值
    {
        System.out.println("Hello World！"); //out是在System类中预定义的静态对象
    }
}

class A = new class(); //Java中，使用关键字 new 来创建一个新的对象

函数格式：

import：提供一个合理的路径，使得编译器可以找到某个类（载入）

基本数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型：byte、short、int、long / float、double / char / boolean

引用数据类型

Java中，引用类型的变量类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。

类型转换

自动类型转换

运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级（小范围可隐式转换为大范围）。

注：int字面值可以赋值给byte/short数据类型（溢出部分从左侧开始计）

强制类型转换

格式：(type)value type 【转换的数据类型必须兼容】

隐含强制类型转换

整数的默认类型是 int
小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或 f

变量类型

局部变量

在方法、构造函数或块内部声明的变量，在声明的方法、构造函数或块执行结束后被销毁。

声明时需初始化。

实例变量/成员变量

在类中声明，但在方法、构造函数或块之外，可以声明在使用前或者使用后，属于类的实例（在对象创建的时候创建，在对象被销毁的时候销毁），每个类的实例都有自己的副本。

可被访问修饰符修饰。

如果不明确初始化，实例变量会被赋予默认值。

静态变量/类变量

在类中用static关键字声明的变量，属于类而不是实例，所有该类的实例共享同一个类变量的值。（静态变量是与类相关的变量，具有唯一性和共享性，可用于存储整个程序都需要使用的数据）

生命周期与程序的生命周期一样长。

访问修饰符可以是 public、protected、private 或者默认的访问修饰符。

在类加载时被初始化，而且只初始化一次。

与常量的区别：

常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。

常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。

参数变量

方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，作用域只限于方法内部。

参数变量值的传递方式：

值传递：传递的是实际参数的值的副本
引用传递：传递的是实际参数的引用（即内存地址），当参数变量被赋新值时会修改原始值

修饰符

访问修饰符

default (即默认，什么也不写）: 在同一包（组织java文件的文件夹）内可见，不使用任何修饰符。

使用对象：类、接口、变量、方法

private : 在同一类内可见。

使用对象：变量、方法。 注：不能修饰类（外部类）和接口

public : 对所有类可见。

使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。（子类与基类不在同一包中时子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。）

使用对象：变量、方法。 注：不能修饰类（外部类）和接口

继承规则：

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中声明为 protected 或 public，不能声明为 private。
父类中声明为 private 的方法，不能够被子类继承。

非访问修饰符

static：修饰方法或变量。（静态变量与方法可直接通过类名来调用）
final：修饰类、方法和变量，final 修饰的类不能被继承、修饰的方法不能被继承类重新定义、修饰的变量为常量故不可修改。
abstract：创建抽象类和抽象方法。
synchronized、volatile：主要用于线程的编程。

运算符 instanceof

用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

如果运算符左侧变量所指的对象，是操作符右侧类或接口的一个对象，则结果为真。若被比较的对象兼容于右侧类型，该运算符仍然返回 true。

使用格式：

( Object reference variable ) instanceof (class/interface type)

For-Each 循环/增强 for 循环

一种主要用于数组的增强型 for 循环。（局部变量的值为数组的循环）

格式：

for(声明语句 : 表达式)

{

//代码句子

}

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

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

数组

声明：

T[ ] array; // 首选的方法，作为函数的参数时也采用这种方式

或

T array[ ]; // 效果相同，但不是首选方法

创建：使用 new 操作符（给声明的数组分配空间）

array = new T[Size];

声明与创建：

T[ ] array = new T[Size];

或

T[ ] arrayr = {value0, value1, ..., valueN};

数组作为函数的返回值：

return array; //返回数组名即可

继承

继承关键字： extends 或 implements （所有类都继承于 java.lang.Object，该类在 java.lang 包中，所以不需要使用 import）

与C++继承的区别：Java中类只能单继承，但可以多重继承

extends

只能继承一个类。

implements

可变相地使 java 具有多继承的特性，使用范围为类继承接口的情况，即类可以同时继承多个接口（接口与接口间用“ ，”分隔）。

其他关键字

super ：可通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

this ：指向自己的引用，引用当前对象，即它所在的方法或构造函数所属的对象实例。

final：可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。【使用 final 关键字声明类，就是把类定义为最终类，不能被继承，但其中的属性、方法不是 final 的；用于修饰方法，即该方法不能被子类重写】

注：

如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表；

如果父类的构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

多态性

多态性是对象多种表现形式的体现。（同一个事件发生在不同的对象上会产生不同的结果）

重写

子类定义了一个与其父类中具有相同名称、参数列表和返回类型的方法，并且子类方法的实现覆盖了父类方法的实现。

重载

在一个类里面，方法名字相同而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

多态存在的三个必要条件：继承、重写、父类引用指向子类对象

多态的实现方式：重写/接口/抽象类和抽象方法

抽象类

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承才能被使用。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

定义：abstract class

抽象方法

该方法的具体实现由它的子类确定。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

封装

实现Java封装的步骤：

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

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问（可采用 this 关键字解决同名冲突）

接口

一个抽象类型，是抽象方法的集合，通常以 interface 来声明。

访问修饰符 interface 接口名

{

//字段

//抽象方法

}

一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口不是类，类描述对象的属性和方法，接口则包含类要实现的方法。

接口无法被实例化，但可以被实现。

一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口类型可用来声明一个变量，他们可成为一个空指针，或是被绑定在一个以此接口实现的对象。

特性

接口是隐式抽象的，接口中的每个方法也是隐式抽象的,即会被隐式的指定为 abstract 。
接口中的方法都是公有的。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public）。
接口中的方法不能在接口中实现，只能由实现接口的类来实现。

接口与类的区别

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8之后接口中可以使用 default 修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。

访问修饰符 class 类名 implements 接口名

{

//字段与方法

}

注：

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
一个类只能继承一个类，但是能实现多个接口。
一个接口能继承另一个接口（同样使用extends关键字），并且可以多继承（Java中的类只能单继承）。

标记接口

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

用途：

建立一个公共父接口
向一个类添加数据类型：实现标记接口的类不需要定义任何接口方法，但能通过多态性变成一个接口类型。

枚举

一个特殊的类，一般表示一组常量。

定义

使用enum 关键字，无需加 class

使用

//声明在类外

enum Color
{
RED, GREEN, BLUE; //一组对象
}
public class Test
{
  public static void main(String[] args)
  {
  Color c1 = Color.RED;
  System.out.println(c1);
  }
}

//声明在类内

public class Test
{
  enum Color
  {
RED, GREEN, BLUE;
  }
  public static void main(String[] args)
  {
  Color c1 = Color.RED;
  System.out.println(c1);
  }
}

注：

每个枚举都是通过 class 在内部实现的，且所有的枚举值都是 public static final
枚举元素可在 for 循环中迭代（类数组），也可用于 switch 语句中

enum Color
{
RED, GREEN, BLUE;  //一组对象
}

public class MyClass

{
          public static void main(String[] args)

        {

//for循环

                for ( Color myVar : Color.values() )

{
        System.out.println(myVar);
}

//switch语句

                 Color myVar = Color.BLUE;
               switch(myVar)

                {
                  case RED:System.out.println("红色");break;
                  case GREEN:System.out.println("绿色");break;
                  case BLUE:System.out.println("蓝色");break;
}
  }
}

枚举类成员

跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 作为访问修饰符，所以外部无法调用。

枚举既可以包含具体方法，也可以包含抽象方法。如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。

包

作用：

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
避免命名冲突。包采用了树形目录的存储方式，同一个包中的类名字不同，不同包中的类的名字可以相同，当同时调用两个不同包中相同类名的类时，应加上包名加以区别。
限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

语法格式

package pkg1.pkg2.pkg3…;

//如果一个源文件开头没有使用包声明，那么其中的类、函数、枚举、注释等将被放在一个无名的包（unnamed package）中

import pkg1.pkg2.classname(.*);

//可以用 import 在源文件头部（package语句后，即包声明之前类声明之后）导入其他包中的类、接口或静态成员，若想使用的是本包中的另一个类可以省略该包名

//可以使用通配符 * 来引入包中的所有类：import com.runoob.mypackage.*;

一些 Java 中的包：