目录
强类型语言（也称为强类型定义语言。所有变量都必须先定义后才能使用 ）：java、vb、c++
一、入门
1、Java的应用
手机应用软件、大型大数据分析平台、 PC端的桌面应用
2、Java系统学习框架
3、Java特性和优势
简单性 面向对象 可移植性（write once,run anywhere）（跨平台 JVM）高性能
分布式 动态性 多线程 安全性 健壮性
4、Java三大版本
JavaSE：标准版（桌面程序、控制台开发......）
JavaME:嵌入式开发（手机、小家电......）仅了解
JavaEE:E企业级开发（web端，服务器开发......）
5、
JDK ：Java Development Kit(Java开发者工具)
JRE：Java Runtime Environment(Java运行时环境)
JVM: Java Virtual Machine(Java虚拟机，可以用软件实现也可以用硬件实现)
6、代码
（1）随便新建一个文件夹，存放代码
（2）新建一个Java文件
文件名后缀为.java （查看当中的文件扩展名打✔）
（3）编写代码
public class Hello {
public static void main(String[] args)
{
System.out.print("Hello,World!");
}
}
（4）编译java java文件，会生成一个class文件
（5）运行class文件，Java class文件
（6）可能会遇到的问题
每个单词的大小写不能出现问题，Java是大小写敏感的
尽量使用英文
文件名和类名必须保证一致，并且首字母大写
符号使用了的中文
二、JAVA基础
1、注释
（不执行，自己看）
JAVA中的注释有三种：
单行注释：只注释当前行，//开始，直到行结束
多行注释：注释一段文字，以/开始， /结束！
文档注释：用于生产API文档，配合JAVAdoc。
2、标识符与关键字
Java 所有组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
注意：
1、标识符以字母A-Z、a-z、$、-(下划线） 开始
2、不能使用以上表格中关键字作为变量名或方法名
3、标识符是大小写敏感
*JAVA不采用ASCII字符集，而采用国际字符集。因此字母可以表示英文、汉字
例如$salary、age、-value
3、数据类型
强类型语言（也称为强类型定义语言。所有变量都必须先定义后才能使用 ）：java、vb、c++
弱类型语言：vb、php
Java的数据类型分为基本类型和引用类型
数据类型拓展
1、整型拓展
对十进制，八进制，十六进制的表示：
十进制整数，99, -500, 0。
八进制整数，以 0 开头，如015。
十六进制数，要求 0x 或 0X 开头 如0x15 。
2、浮点型拓展
1. 默认double
2. 浮点数存在舍入误差，很多数字不能精确表示。如需进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
3. 避免比较中使用浮点数
3、字符型拓展
4、类型转换
1、自动类型转换
2、强制类型转换
Java是强类型语言，进行有些运算时，需要用到类型转换。
数据类型转换必须满足如下规则：
不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度
5、变量、常量、作用域
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
1、变量
（1）Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
（2）每个变量都有类型，类型可以是基本类型，也可以是引用类型。
（3）变量名必须是合法的标识符。
（4）变量声明是一条完整的语句，因此每一个声明都必须以分号结束
（5）一行内可声明多个变量，但不建议使用，可读性低
2、变量作用域
变量根据作用域可划分为三种：
1、类变量（静态变量）：独立于方法之外的变量，用 static 修饰。
2、实例变量（成员变量）：独立于方法之外的变量，没有 static 修饰。
3、局部变量：类的方法中的变量。 （方法或语句块内部定义的变量）
3、命名规范
（1）. 所有变量、方法、类名：见名知意
（2）. 类成员变量：首字母小写和驼峰原则 : monthSalary
（3）. 局部变量：首字母小写和驼峰原则
（4） 常量：大写字母和下划线：MAX_VALUE
（5）. 类名：首字母大写和驼峰原则: Man, GoodMan
（6）. 方法名：首字母小写和驼峰原则: run(), runRun()
6、运算符
Java 语言支持如下运算符：
算术运算符: +，-，*，
赋值运算符 =
关系运算符: >，<，>=，
逻辑运算符: &&，||，!
位运算符: &，|，^，~ ， >>等
扩展赋值运算符:+=，-=，*=，/=
1、二元运算符 （两个操作数）
整数运算 浮点运算 关系运算符
取模运算 （取余)
操作数可以为浮点数,一般使用整数
*负数%负数＝负数；
负数%正数＝负数；
正数%负数＝正数；
一般都是正整数运算，进行结果的判断
2、一元运算符
自增自减运算符是一个操作数，分前缀和后缀两种
*int a = 3^2; //java中不行， ^是异或符号
特殊的运算都需要运用到math类提供的方法
3、逻辑运算符
4、位运算符
Java位运算符应用于整数类型，长整型，短整型，字符型和字节型 等类型。
位运算符作用在所有的位上，并且按位运算。
5、扩展运算符
6、字符串连接符
“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串再进行连接。
7、三目条件运算符
语法格式：x ? y : z
7、包机制
包的作用：
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包这种机制是为了防止命名冲突，访问控制，提供搜索和定位
包语句的语法格式：
package pkg1;//一个包相当于一个文件夹
一个包可以定义为一组相互联系的类型并为这些类型提供访问保护和命名空间管理的功能。
创建包
取名：包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包中。
import 关键字
用途：通过该关键字实现在 Java 程序中明确导入特定包，以使用该包的某个成员import
语法格式：package1[.package2…].(classname|*);
注意：
用 import 关键字引入，使用通配符 "*" , 导入io包下的所有类
类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前
JavaDoc生成文档
JavaDoc是一种将注释生成HTML文档的技术，（HTML文档类似于Java的API，易读）
作用：它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档
用户交互Scanner及拓展
1、Scanner对象
java.util.Scanner 是 Java5 的新特征，可通过 Scanner 类来获取用户的输入
创建scanner对象的基本语法：
Scanner s = new Scanner(System.in);
2、next & nextLine
next() 与 nextLine()是Scanner 类的两个方法，区别及特征：
next():
1、读到有效字符后才能结束输入。
2、可自动去掉输入有效字符之前遇到空白。
3、输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、不能得到带有空格的字符串。
nextLine()：
1、以Enter为结束符
2、可获得空白
import java.util.*;
public class N1 {
public static void main(String args[]){
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner=new Scanner(System.in);
System.out.println("使用next方式接受：");
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用next方式接收
String str=scanner.next();
System.out.println("输出的内容为："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源， 要养成好习惯，用完就关掉
scanner.close();
}
}
/*从键盘依次输入若干数字，最后从键盘输入一个非数字字
符串结束整个输入操作过程，程序计算这些数的和和平均值*/
import java.util.*;
public class Example {
public static void main (String args[]){//快捷键：psvm回车
Scanner reader=new Scanner(System.in);
double sum=0;
int m=0;
while(reader.hasNextDouble()){
double x=reader.nextDouble();
m=m+1;
sum=sum+x;
}
System.out.printf("%d个数的和为%f\n",m,sum);
System.out.printf("%d个数的平均值为%f\n",m,sum/m);
}
}
顺序结构
JAVA最基本最简单的结构，非特别指明，都按照顺序依句执行
选择结构
if单选择结构
if语句对条件表达式进行一次测试，测试为真，执行下面语句，否则跳过
if(布尔表达式）{ }
//扩展：s.equals("h")判断s和h两个字符串是否相等
if双选择结构
作用：当条件表达式为真时，执行语句块1，否则执行语句块2。
if(布尔表达式）{
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
if多选择结构
if(布尔表达式1）{
}else if(布尔表达式2){
}else if(布尔表达式3){
}else{
}
if 语句后面可跟 else if…else 语句
注意：
if 语句最多有 1 个 else 语句，else 语句在所有的 else if 后
if 语句可以有若干个 else if 语句，必须在 else 前
若其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行
嵌套的if结构
使用嵌套的 if…else 语句是合法的。
所有的流程控制语句都可以互相嵌套，互不影响
if(布尔表达式1){
if(布尔表达式2）{
}
}
switch多选择结构
多选择结构还有一个实现方式就是switch case 语句。
switch case 语句有如下规则：
1、switch 语句中的变量类型可以是： byte、short、int 或者 char。
2、Java SE 7 switch 开始支持字符串 String 类型且 case 标签必须为字符串常量或字面量。
3、switch 语句可以拥有多个 case 语句。每个case后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与case语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现 才会跳出switch语句。
switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断 是否继续输出，或是跳出判断。
case穿透
如果case语句块中没有 break 语句时，从当前case开始，后续所有 case 的值都输出。如果后续的case语句块有break语句则会跳出判断
switch(expression){
case value:
//语句
break;//可选
case value:
//语句
break;//可选
//可以有任意数量的case语句
default: //可选，找不到可以匹配的值就执行default语句
//语句
}
循环结构
Java中三种主要的循环结构：
while 循环
do…while 循环
for 循环
while 循环
我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
方式有：循环内部控制，外部设立标志位！等
少部分情况需要循环一直执行，比如服务器的请求响应监听等。
循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影
响程序性能或者造成程序卡死奔溃！
do…while 循环
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次
While和do-While的区别：
while先判断后执行。dowhile是先执行后判断！
For循环
特点
1、for循环语句：支持迭代的一种通用结构，是最有效灵活的循环结构。
2、for循环执行的次数是在执行前就确定的。
for循环可在已知循环次数的情况简化代码，提高可读性。是平时使用最多的循环
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句
块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
增强for循环
for(声明语句：表达式）
{
//代码句子
}
break & continue
1、break 关键字
作用:
（1）、在循环语句或者 switch 语句中，用来跳出整个语句块
（2）、跳出最里层的循环，并且继续执行该循环下面的语句
2、continue 关键字
作用:让程序跳转到下一次循环的迭代
for 循环中，continue 语句使程序立即跳转到更新语句
while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句
3、两者区别
break在任何循环语句的主体部分，均可用break控制循环的流程。
break用于强行退出循环，不执行循环中剩余的语句。
continue 语句用在循环语句体中，用于终止某次循环过程，接着进行是否执行循环的判定。
方法
什么是方法
Java方法：语句的集合，一起执行一个功能。（功能块）
方法是解决一类问题的步骤的有序组合 ，包含于类或对象中，程序中被创建，在其他地方被引用
设计方法的原则：保持方法的原子性，（一个方法只完成一个功能，利于后期扩展）
public class N1 {
public static void main(String[] args) {
int sum=add(1,2);//add方法是类方法可以直接用类名调用
System.out.println(sum);
}
public static int add(int a,int b){//如果不加static则不能直接用类名调用
return a+b;
}
}
方法的优点
1、使程序简短清晰。
2、利于程序维护。
3、提高程序开发效率。
4、提高了代码重用性
方法的定义与调用
方法定义：
方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，包含一个方法头和一个方法体
方法的所有部分：
1、修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
2、返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
3、方法名：方法的实际名称。方法名和参数表共同构成方法签名。
4、参数类型：当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数可选，方法可以不包含任何参数。
形式参数：在方法被调用时用于接收外界输入的数据
5方法体：方法体包含具体的语句，定义该方法的功能。
方法调用
调用方法：对象名.方法名（实参列表）
当方法返回一个值时，方法调用通常被当作一个值
int large=max(30,40);
如果方法返回值是void，方法调用一定是一条语句
System.out.println("hello,word");
public class N2 {
public static void main(String[] args) {
int max=max(10,20);
System.out.println(max);
}
public static int max (int a,int b){
int result=0;
if(a==b){
System.out.println("a==b");
return 0; //终止方法
}
if(a>b){
result=a;
}else{
result=b;
}
return result;
}
}
方法的重载
方法重载：
当调用max方法时传递int型参数，则 int型参数的max方法就会被调用；
当传递double型参数，则double类型的max方法体会被调用。
意义：
方法重载使程序清晰易读。执行密切相关任务的方法时应使用相同名字。
重载的方法必须拥有不同的参数列表
可变参数
方法的可变参数的声明如下所示：
typeName... parameterName
一个方法中只能指定一个可变参数，且必须是方法的最后一个参数。
任何普通的参数必须在它之前声明。
public static void printMax( double. . . numbers) {
if (numbers.length == 8) {
System.out.print1n("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);
}
递归
递归：A方法调用A方法(自己用自己）
注意指明跳出时间，否则会成为死循环
利用递归可以用简单的程序来解决一些复杂的问题。可将一个大型复杂的问题转化为一个与原问题相似的小规模问题来求解递归，递归结构包括递归头和递归体
数组
是一个类型的所有数据的一个集合
数组的定义：
数组是相同类型数据的有序集合.
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,可以通过一个下标访问
数组的四个基本特点：
1. 长度确定。数组一旦创建，大小不可改变。
2. 元素必须相同类型,不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组对象本身是在堆中的
数组声明创建
1、声明数组
首先必须声明数组变量，才能在程序中使用数组。
Java语言使用new操作符来创建数组：
arrayRefVar = new dataType[arraySize];
2、含义
一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
三种初始化及内存分析
三种初始化
1、静态初始化
除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值
2、动态初始化
数组定义、为数组元素分配空间、赋值的操作分开进行
3、数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也按照实例变量同样的方式被隐式初始化。
内存分析
1. 因此声明数组时不能指定其长度(数组中元素的个数)，例如：int a[5]; //非法
2. 声明一个数组的数组没有被真正的创建。
3. 构造一个数组必须指定长度
P54数组边界
*数组是相同数据类型(数据类型可以为任意类型)的有序集合
*数组也是对象，相当于对象的成员变量
*数组长度的确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds
P55数组使用
1、For-Each 循环
JDK 1.5 引进的一种新的循环类型： For-Each 循环或者加强型循环，能在不使用下标的情况下遍历数组。
2、数组作方法入参
3、数组作返回值
多维数组 把两个或者多个值当做定位
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
（1）多维数组的动态初始化
（2）多维数组的引用
（3）获取数组长度
Arrays 类
数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
java.util.Arrays 类能方便地操作数组. 使用之前需要导包
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用
具有以下常用功能：
给数组赋值：通过 fifill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
冒泡排序
原理
1. 比较相邻的元素。1>2 则交换。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
选择排序
一种简单直观的排序算法。
原理是每一次从待排序的数据元素中 选出最小（或最大）的一个元素，存放在序列的起始位置，再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列的末尾。以此类推，直到全部待排序的数据元素排完。
选择排序不稳定
稀疏数组
一种数据结构
当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，稀疏数组的处理方法是：
1、记录数组一共有几行几列，有多少个不同的值
2、把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
什么是面向对象
Java是面向对象的，采用这种语言进行编程称为面向对象编程。
面向对象编程的本质：以类的方式组织代码，以对象的组织(封装)数据。
创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
构造器
类中的构造器也称为构造方法，在进行创建对象的时候必须要调用的。
构造器特点:
1. 必须和类的名字相同
2. 必须没有返回类型,也不能写void
构造器的作用:
1. 使用new创建对象的时候必须使用类的构造器
2. 构造器中的代码执行后,可以给对象中的属性初始化赋值
构造器之间的调用
使用this关键字,在一个构造器中可以调用另一个构造器的代码。
注意:this不会产生新的对象,只调用构造器中的代码.只有使用new关键字才会创建新对象。
默认构造器
编译之后自动添加的一个无参构造器,也称为默认构造器。
内存分析
栈 stack：
1. 每个线程私有，不能实现线程间的共享
2. 局部变量放置于栈中。
3. 栈是由系统自动分配，一个连续的内存空间
堆 heap：
1. 放置new出来的对象
2. 一个不连续的内存空间，分配灵活速度慢
方法区(一种堆)：
1. 被所有线程共享
2. 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）
java的三大特征：继承、封装、多态。
封装的作用和意义
1. 提高程序的安全性，保护数据。
2. 隐藏代码的实现细节
3. 统一用户的调用接口
4. 提高系统的可维护性
5. 便于调用者调用
继承
1. 继承是类和类之间的一种关系。
2. 继承关系的俩个类，一个为子类,一个为父类。
3. 子类和父类之间,应该具有"is a"的关系.
4. 类和类之间的继承是单继承
5. 父类中的属性和方法可以被子类继承
Super关键字
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法【调用父类中的构造器】
不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置
使用注意：
1. 用super调用父类构造方法，必须是构造方法中的第一个语句。
2. super只能出现在子类的方法或者构造方法中。
3. super 和this不能够同时调用构造方法。
方法重写
方法的重写
1. 方法重写只存在于子类和父类之间。在同一个类中方法只能被重载，不能被重写.
2. 静态方法不能重写
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
a、有继承关系
b、子类重写父类方法
c、父类引用指向子类对象
注意:多态是方法的多态，属性没有多态性。
instanceof
static修饰符
1、static变量
在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。
静态变量和非静态变量的区别
静态变量属于类,可使用类名来访问,非静态变量是属于对象的,必须使用对象来访问.
2、static方法
在类中,使用static修饰的成员方法,就是静态方法,反之为非静态方法。
父类的静态方法可以被子类继承,但不能被子类重写
父类的非静态方法不能被子类重写为静态方法
接口
接口的本质
普通类：只有具体实现
抽象类：包括具体实现和规范(抽象方法)
接口与抽象类的区别
抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口
注：接口中的方法都是抽象方法、一个接口可以继承多个父接口
内部类
内部类分为四种：
1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类
异常
异常发生的原因
1、输入了非法数据。
2、文件不存在。
3、网络中断、JVM内存溢出。
异常之间的区别与联系
1、Error
类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
通常是灾难性的致命的错误，程序无法控制和处理
2、Exception
通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
Java异常处理机制
1、抛出异常
2、捕获异常
异常处理五个关键字
Try：用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
Catch：用于捕获异常。catch用来捕获try语句块中发生的异常。
fifinally -- fifinally语句块总是会被执行。它主要用于回收在try块里打开的物力资源
Throw：抛出异常。
Throws：用于方法签名中，用于声明该方法可能抛出的异常。
try, catch,fifinally ,return 执行顺序：
1．执行try，catch ，给返回值赋值
2．执行fifinally
3．return
自定义异常
在程序中使用自定义异常类，大体可分为以下几个步骤:
1、创建自定义异常类。
2、在方法中通过throw关键字抛出异常对象。
3、如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的
4、声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
5、在出现异常方法的调用者中捕获并处理异常。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
