Java基础语法(一文让你通学java基础语法!!!)
Java基础语法
1.注 释:
Java的注释有3种，分别是单行注释、多行注释、文档注释，格式如下
//单行注释
/*多行注释*/
/**文档注释*/
2.数据类型
java是一种强类型语言.这就意味着必须为每一个变量声明一种数据类型,在java中一共有8种数据类型,分别如下:
2.1.整型(4种)
| 类型 | 存储需求 | 取值范围 |
|---|---|---|
| byte | 1字节 | -128~127 |
| short | 2字节 | -32 768~32 767 |
| int | 4字节 | -2 147 483 648~214 748 647 |
| long | 8字节 | -9 223 372 036 854 775 808~9 223 372 036 854 775 807 |
在java中,整型的范围与运行java代码的机器无关,这就解决了软件从一个平台移植到另一个 平台或者同一个平台不同操作系统的问题,相反C程序会针对不同的处理器选择最为高效的整型,这样会造成一个在32位处理器上运行很好的C程序在16位操作系统上运行时却发生溢出.由于java程序必须保证在每个机器上的运行结果相同,所以各种数据类型的取值范围必须固定.
2.2.浮点类型(2种)
浮点类型数据用于表示有小数部分的数值,在java中有2种浮点类型,分别如下:
| 类型 | 存储需求 | 取值范围 |
|---|---|---|
| float | 4字节 | 1.4E-45~3.4028235E38 (E是一个16进制数位) |
| double | 8字节 | 4.9E-324~1.7976931348623157E308 |
2.3.char类型(1种)
char类型的值需要用单引号括起来,例如’A’是编码值为65的字符常量,而"A"是一个字符串.
| 类型 | 存储需求 | 取值范围 |
|---|---|---|
| char | 2字节 | 0~65535 |
2.4.boolean类型(1种)
boolean类型一般用来判定逻辑条件,注意:整型值与boolean值之间不能进行相互转换.
| 类型 | 存储需求 | 取值范围 |
|---|---|---|
| boolean | 1字节 | true / false |
java 字符串转换为Boolean值可以通过Boolean.valueof来实现字符串到boolean值的转换：只有字符串为true 且忽略大小写比如：True/TRue/TRUE等返回布尔值true，其他都返回false.
Boolean b1 = Boolean.valueOf("true");
System.out.println(b1);// true
Boolean hh = Boolean.valueOf("hh");
System.out.println(hh);// false
Boolean aFalse = Boolean.valueOf("false");
System.out.println(aFalse);//false
Boolean aTrue = Boolean.valueOf("True");
System.out.println(aTrue);//true
Boolean aBoolean = Boolean.valueOf(null);
System.out.println(aBoolean);// false
3.变量与常量
3.1.常量
在java中,有多种类型常量,例如:
//字符串常量： 双引号括起来的内容
System.out.println("hello");
//字符常量： 单引号括起来的的一个字符
System.out.println('a'); //小写字符
System.out.println('A'); //大写字符
System.out.println('1'); //数字字符
System.out.println('中'); //文中字符
System.out.println('+'); //符号字符
//整数常量：直接写的数字
System.out.println(100);
//浮点常量：只写的小数
System.out.println(3.14);
//布尔常量：true或者false
System.out.println(true);
System.out.println(false);
//空常量：null(该常量不能打印输出)
还有一种使用关键字final指示常量,一般希望某个常量可以在一个类的多个方法中使用,通常称这些为类常量,一般使用 static final 设置一个类常量,需要注意:类常量一般要放在main方法外,如果使用public 修饰的话,多个类都可以使用这个类常量.
3.2.变量
变量从字面上理解就是可以发生改变的量。变量的本质其实是内存中的一小片内存空间，用来存储一个数据，而这个空间的的数据可以在一定范围内发生改变（这里所说的一定范围，就是数据类型）
3.2.1.变量声明和使用
格式
//单独定义变量
数据类型 变量名;
//定义变量并赋值
数据类型 变量名=初始值;
声明变量并使用
public static VariableDemo1{
public static void main(String[] args){
//单独声明变量
int a;
a=10; //给变量a赋值为10
System.out.println("a的值："+a);
a=20; //修改变量a的值为20
System.out.println("a的值："+a);
//定义变量并赋值
int b=10;
System.out.println("b的值："+b);
b=20; //修改变量b的值为20
System.out.println("b的值："+b);
}
}
3.2.1.变量的细节问题
变量的初始值:
变量没有赋值，不能够直接使用
public class VariableDemo2{
public static void main(String[] args){
//指定定义了变量，没有赋值
int a;
//没有赋值的变量，不能直接使用
System.out.println(a); //编译报错
}
}
变量的作用域:
作用域指的是变量所在的{}范围内，一个变量定义在哪个{}范围内，就只能在哪个范围内有效。看如下代码
public class VariableDemo3{
public static void main(String[] args){
//变量a的作用域为 第3行~13行
int a=10;
{
//变量b的作用域为 第5行~9行
int b=20;
System.out.println(b); //正确
}
System.out.println(a); //正确
//这里超过了变量b定义的{}范围
System.out.println(b); //编译报错
}
}
同一行定义多个变量:
可以在一行定义多个相同类型的变量，代码如下:
public class VariableDemo4{
public static void main(String[] args){
//a和b都是int类型，值分别为3和4
int a=3,b=4;
System.out.println(a);
System.out.println(b);
}
4.数据类型转换
数据类型转换指的是同一个数据可以用不同的数据类型存储。比如我们需要用一个变量来表示整数10，能用那些数据类型来存储呢？我们发现byte、short、int、long都能存储整数10。
当这个变量先用byte类型存，后来又用int类型存，我们就说这个变量发生了自动类型转换；
当这个变量先用int类型存，后来又用byte类型存，我们就说这个变量发生了强制类型转换
4.1.自动类型转换(小转大)
public class DateTypeCastDemo1{
public static void main(String[] args){
//把整数10赋值给byte类型的变量a
byte a=10;
//变量a从byte类型转为int类型
int b=a;
}
}
以上代码中数据10刚开始用byte类型存储，后来用int类型存储，像这种从小大到的转换叫做自动类型转换，它不会改变数据大小。
4.2.强制类型转换(大转小)
//强制类型转换格式
数据类型 变量名=(数据类型)被转换的数据;
public class DateTypeCastDemo1{
public static void main(String[] args){
//把整数127赋值给byte类型
int a=127;
//把int类型的变量a强制转换byte类型
byte b=(byte)a;
}
}
此处我们可以理解成小桶水倒进大桶里完全可以(自动类型转换),大桶水倒进小桶里,需要大桶舍弃一些水然后倒进小桶(强制类型转换).
5.运算符
运算符就是在程序中参与运算符的符号，下面是我们要学习的一些运算符.
5.1.算数运算符
我们先来学习算数运算符的 +(加) -(减) *(乘) /(除) 以及 %(取模).
| 运算符 | 含义 |
|---|---|
| + | 加法运算、字符串拼接 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算，整数相除只能得到整数 |
| % | 取模(余数) |
用代码演示一下:
public class ArithmeticDemo1{
public static void main(String[] args){
System.out.println(5+3); //加法运算：8
System.out.println(5-3); //减法运算：2
System.out.println(5*3); //乘法运算：15
System.out.println(5/3); //除法运算：1
System.out.println(5%3); //取余运算：2
//需要注意的是整数相除只能得到整数
System.out.println(5/2); //2
//如果想得到小数必须有小数参与运算
System.out.println(5.0/2); //2.5
}
}
5.1.1.+ 符号的其他用法
+符号不仅仅能做加法运算，它与字符和字符串参与运算还有其他功能。下面来看代码演示.
public class ArithmeticDemo2{
public static void main(String[] args){
//+符号与数值运算： 普通加法运算
System.out.println(3+4); //7
//+符号与字符运算： 先把字符转为int，再做加法运算
System.out.println('a'+1); //98
//+符号与字符串运算：字符串连接符
Sytem.out.println("hello"+5+5); //hello55
System.out.println(5+5+"hello"); //10hello
System.out.println("5+5="+10); //5+5=10
}
}
5.1.2.自增与自减
自增、自减两个特殊的运算符，它是自身原有数据上加1或者减1.
| 运算符 | 含义 |
|---|---|
| ++ | 自增 |
| – | 自减 |
++和–运算符的使用要两种情况来看，第一种是单独使用，第二种是混合使用。我们先来学习单独使用.
单独使用:
++和–放在操作数前面和后面，结果都是一样的，最终结果都会在原有数据上自增1或者自减1
public class ArithmeticDemo3{
public static void main(String[] args){
int a=3;
int b=4;
a++; //等价于 ++a
System.out.println(a); // 4
b--; //等价于 --bb
System.out.println(b); // 3
}
}
混合使用
++或者–可以放在操作数前面，也可以方法操作数后面。不管++或者–放在操作数后面还是前面，该自增1还是会自增1，该自减1还是会自减1，只是运算顺序有所不同
我们以++和赋值运算混合使用为例来做代码演示；–的用法和++类似，自己完成。
public class ArithmeticDemo4{
public static void main(String[] args){
int a=3;
//等价于a++; int b=a;
int b=++a;
System.out.println();//4
System.out.println(a);//4
int x=3;
//等价于int y=x; x++
int y=x++;
System.out.println(x);
System.out.println(y);
//常量不能做自增、自减运算
System.out.println(5++); //错误写法
}
}
总结一下：不管++(–)放在操作数的前面还是后面，最终都得+1或者-1，只不过运算顺序不一样
注意：常量不能做自增和自减运算
5.2.赋值运算符
赋值运算符的用途是把右边的结果赋值给左边。分为基本的赋值运算和扩展的赋值运算符。
先来看一下基本的赋值运算符，我们直接用代码演示
| 运算符 | 含义 |
|---|---|
| = | 把右边的值赋值给左边 |
public class AssignDemo1{
public static void main(String[] args){
//把右边的整数10,赋值给左边的int变量a
int a=10;
}
}
接下来学一下扩展的赋值运算符，分别为+=、-=、*=、/=、%=，它们用于把左右两边运算的结果重新赋值给左边。下面看一下代码演示
| 运算符 | 含义 |
|---|---|
| += | 左右两边相加的结果赋值给左边 |
| -= | 左右两边相减的结果赋值给左边 |
| *= | 左右两边相乘的结果赋值给左边 |
| /= | 左右两边相除的结果赋值给左边 |
| %= | 左右两边取余数的结果赋值给左边 |
public class AssignDemo2{
public static void main(String[] args){
int a=20;
//把a+10之结果再赋值给a,最终a=30
a+=10;
System.out.println(a); //30
int b=5;
//把b/2之结果再赋值给b,最终a=2
b/=2;
System.out.println(b); //2
int c=10;
//把y对4取余数的结果再赋值给y,最终,c=2
c%=4;
System.out.println(c); //2
//注意：扩展的赋值运算符，隐含的有一个强制类型转换
byte s=3;
s+=4；//等价于 s=(byte)(s+4);
System.out.println(s); //7
}
}
5.3.比较运算符
用来对两个数据做比较运算，最终结果只能是true或者false
| 运算符 | 含义 |
|---|---|
| ">‘’ | 大于 |
| ‘’>=‘’ | 大于等于 |
| < | 小于 |
| <= | 小于等于 |
| == | 判断相等 |
| != | 判断不相等 |
5.4.逻辑运算符
逻辑运算可以对多个boolean条件进行连接，最终结果也是true或者false
| 运算符 | 含义 |
|---|---|
| &(与) | 两个条件都满足结果才是true |
| ∣(或) | 有一个条件满足结果就是true |
| !(非) | 对结果取反 |
| &&(双与) | 两个条件都满足结果才是true，左边为false右边不运算 |
| ∣∣(双或) | 有一个条件满足结果就是true，左边为true右边不运算 |
int a=3;
int b=4;
int c=5;
//&(与)： 左右两边都是true,结果才是true
System.println(a>b&bb|bb&&bb||b 5.5.三元运算符(条件运算符)
格式：数据类型 变量名 = 关系表达式 ? 表达式1 : 表达式2;
执行流程：
首先判断关系表达式的结果是true还是false,
如果关系表达式是true,三元运算的结果就是表达式1,
如果关系表达式是false,三元运算的结果就是表达式2,
注意:三元运算的结果必须被使用，要么直接打印输出，要么使用变量存起来.
5.6.运算符优先级
| 优先级 | 运算符 | 结合性 |
|---|---|---|
| 1 | []、()(方法调用) | 从左向右 |
| 2 | !、+、-、~、++、– | 从右向左 |
| 3 | *、/、% | 从左向右 |
| 4 | +、- | 从左向右 |
| 5 | <<、>>、>>> | 从左向右 |
| 6 | <、<=、>、>=、instanceof | 从左向右 |
| 7 | ==、!= | 从左向右 |
| 8 | & | 从左向右 |
| 9 | ^ | 从左向右 |
| 10 | I | 从左向右 |
| 11 | && | 从左向右 |
| 12 | II | 从左向右 |
| 13 | ?: | 从右向左 |
| 14 | =、+=、-=、*=、/=、&=、I=、^=、~=、«=、»=、>>>= | 从右向左 |
6.字符串(后续使用比较多,重点学习)
字符串在实际开发中用到的特别多,接下来我们先学习字符串的两种创建方式,分别如下:
第一种:直接赋值
String s1="hello world";
创建的字符串s1对象，只会在常量池中。hello world属于字面量(常量)，创建s1对象的时候，JVM会先去常量池中通过equals(key)方法，判断是否有相同的对象
如果有，则直接返回该对象在常量池中的引用；
如果没有，则会在常量池中创建一个新对象，再返回引用
第二种:使用new String()来创建字符串
String s2 = new String("你好");
此时有两种情况:
1.JVM首先会查找字符串池中是否存在值为"你好"的对象,如果存在,则直接去堆内存中创建一个"你好",并将堆内存中的“你好”对象的引用（内存地址）赋给变量s2.
2.JVM首先会查找字符串池中是否存在值为"你好"的对象，发现不存在，则在字符串池中创建一个“你好”的对象，在堆内存中也创建一个“你好”对象，并将
堆内存中的“你好”对象的引用（内存地址）赋给变量s2;
实例：
String s1 = new String("hello"); ①
String s2 = new String("hello");②
String s3 = "hello";③
String s4 = "hello";④
String s5 = "你好";⑤
程序按顺序执行理解示意图:
6.1.字符串常用操作
6.1.1.截取子串
String类的 subString 方法可以从一个较大的字符串中提取一个子串.例如:
String s1 = "hello";
String s2 = s1.subString(0,3); // 从hello的0位置开始复制到第3位,但不包含第3位.
System.out.println(s2); // 结果是hel
6.1.2.拼接
拼接即连接两个字符串,话不多说,直接上示例:
第一种情况:
String s1 = "hello,";
String s2 = "world";
String s3 = s1+s2;
System.out.println(s3); // "hello,world"
第二种情况:
如果一个字符串与一个非字符串的值进行拼接,那么后者会转换成字符串进行拼接.
int age = 10;
String s4 = "5+5=";
String s5 = s4+age;
System.out.println(s5); // "5+5=10"
6.1.3.字符串分割
String类的split（）方法可根据给定的分隔符对字符串进行拆分。
String s1 = "你好,我好,大家好";
String [] split = s1.split(",");
for(int i=0 , i < split.length , i++ ){
System.out.println("索引" + i + "位置的元素为:"+ split[i]);
// "索引0位置的元素为:你好"
// "索引1位置的元素为:我好"
// "索引2位置的元素为:大家好"
}
6.1.4.字符串分割
String 类中contains( )方法可以判断字符串是否包含指定内容。
String s1 = "Java编程思想";
boolean a = s1.contains("Java");
System.out.println(a); // true
6.1.5.比较字符串是否相等
比较字符串对象的内容是否相同，就需要用equals()方法。并且进行比较的字符串不为null，内容相同返回true。
注意:比较时前者不允许为null，否则直接报错，后者可以为null。
String s1 = "abc";
String s2 = "abc";
String s3 = "bcd";
System.out.println(s1.equals(s2)); //true
System.out.println(s1.equals(s3)); //false
7.输入输出
首先我们要学会使用基本的控制台实现输入输出.
7.1.读取输入
- 1.导包，写在class类的上面
import java.util.Scanner;
- 2.创建Scanner对象
Scanner sc=new Scanner(System.in);
- 3.调用方法获取键盘录入数据
int num=sc.nextInt(); //读取整数
double num1 = sc.nextDouble(); //读取一个浮点数
7.2.格式化输出
System.out.print(); // 不换行打印
System.out.println(); // 换行打印
7.3.随机数
接下来我们要学习一个知识点叫做随机数，和键盘录入非常类似，我们来看一下。
产生随机数的步骤
//1.导包(可以先不写，由Idea自动导入)
import java.util.Random;
//2.创建随机数对象
Random r=new Random();
//3.获取键盘录入数据
int num=r.nextInt(10); //这里的10，表示随机数的范围是[0,10)
我们来做一个代码的演示
//1.导包
import java.util.Random;
public class Demo1{
public static void main(String[] args){
//2.创建Random对象
Random r=new Random();
//获取10个随机数
for(int i=1;i<=10;i++){
int num=r.nextInt(10);
System.out.println(num);
}
}
}
8.控制流
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的，也就是说程序的流程对运行结果有直接的影响。在清楚每条语句的执行流程的前提下，才能通过控制语句的执行顺序来实现我们要完成的功能。
8.1.if语句
if是如果的意思，用来对条件进行判断，根据条件判断的结果是否成立，选择性的执行不同的语句体。
8.1.1.单if语句
先来看一下单if语句的格式和执行流程
//如果条件成立，执行下面的语句体；否则不执行
if(条件判断){
语句体;
}
键盘录入一个整数，判断这个整数是否为偶数，如果这个数是偶数，就是输出”xx是偶数“(xx表示你输入的数)
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数：");
int num=sc.nextInt();
//判断num是否为偶数
if(num%2==0){
System.out.println(num+"是偶数");
}
上面代码只能判断输入的数是偶数的情况，输出这个数是偶数；如果输入的数不是偶数，将什么也做不了。所以就有了下面的if…else语句
8.1.2. if…else语句
还是先来看一下，if...else语句的格式和执行流程
//如果条件成立执行，语句体1;否则执行语句体2;
if(条件){
语句体1;
}else{
语句体2;
}
键盘录入一个整数，判断这个整数是否为偶数，如果这个数是偶数，就是输出”xx是偶数“；否则输出”xx是奇数“(xx表示你输入的数)
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数：");
int num=sc.nextInt();
//判断num是否为偶数
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
8.1.3. if…else if语句
如果我们需要对两种以上的情况进行判断，就可以用if…else if语句.
if(条件1){ //如果条件1成立，执行语句体1
语句体1;
}else if(条件2){ //如果条件2成立，执行语句体2
语句体2；
}else{ //如果以上条件都不成立，执行最后的else
语句体n+1;
}
8.1.4.if语句的注意事项
在使用if语句时，注意下面几个问题:
1. if后面()中的条件判断语句必须是boolean类型.
2. 如果是多个条件的情况，只会执行第一个条件为true的语句体；后面的条件就不再执行.
3. 如果{}中的语句体只有1条语句，{}可以省略
8.2.switch语句
switch语句用于在几个固定的值之间进行选择，如一个星期有7天，一年有12个月等等。废话少说，我们直接用一个案例来学习switch语句。根据键盘录入的整数，输出对应的星期。
Scanner sc=new Scanner(System.in);
int week=sc.nextInt();
//假设键盘录入的是5，下面的case 5与之匹配，就执行该处的语句体。
//遇到break就结束，如果没有遇到break会穿透(你可以尝试删掉break试一下)
switch(week){
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
}
switch语句有下面的几个注意事项
switch小括号中的变量，类型只能是下面几种:
- byte short int char
- JDK7之后可以是字符串 （目前市场上用的最多的版本是JDK8）
- JDK5之后可以是枚举
- case后面的值只能是常量，不能是变量
- case后面的值不能重复
- break可以省略，但是会穿透
8.3.for语句
for这个单词没有特殊含义，它仅仅只表示接下来的代码是循环语句，有自己的执行流程。
/*
执行流程：
1.先执行初始化语句;
2.再执行条件判断语句;
如果条件为true，就执行循环语句体;
如果条件为false，就跳出循环，执行循环之后的代码
3.条件控制语句
4.回到2步骤继续执行
*/
for(初始化语句;条件判断语句;条件控制语句){
循环语句体;
}
注意: 在开发中可能要遇到两层for循环,但是在条件成立时就要跳出两层for循环,而continue只是跳出本次循环,执行下次循环,还有break是跳出本层循环,并不能满足需求,所以我们需要借助break的标记,从而实现跳出两层for循环
flag: //借助标记跳出两层for循环
for(初始化语句;条件判断语句;条件控制语句){
for(初始化语句;条件判断语句;条件控制语句){
if(条件){
循环语句体;
break flag;
}
}
}
8.4.while语句
接下来学习另外一种循环语句，叫做while循环，while循环的执行流程其实和for循环是一模一样的，只是格式不一样。在实际开发中根据需求来进行选择.
我们还是先学习一下while循环的格式和执行流程
初始化语句;
while(条件判断语句){
循环语句体;
条件控制语句;
}
我们通过一个简单的案例，来学习一下它的执行流程。打印输出5个"helloworld"
int i=1;
while(i<=5){
System.out.println("helloworld");
i++;
}
/*
执行流程分析：
1) 开始i=1;
2) 判断i<=5是否成立
如果条件成立，执行大括号中的代码 打印输出一个"helloworld"
如果不成立，while循环结束。
3) 执行i++，i变成2
4) 继续回到2步骤执行
*/
8.5.do while语句
还是通过一个简单得案例来演示，打印输出10个"helloworld".
int i=1;
do{
System.out.println("helloworld");
i++;
}while(i<=10);
do...while循环有一个特点，就是不管条件是否成立，循环语句体先执行一次再说。
9.数组
数组是用来存储多个数据的容器，有下面几个特点。
1.元素类型是一致的.
2.长度是不可变的.
9.1.数组的格式
//格式1：数据类型[] 数组名 = new 数据类型[长度];
int[] arrayA=new int[3];
//格式2：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素....};
int[] arrayB=new int[]{10,20,30};
//格式3：数据类型[] 数组名 = {元素1,元素2,元素....};
int[] arrayC={10,20,30};
9.2.数组的元素访问
在数组中每一个元素都有一个索引与之对应，这个索引其实就是一个从0开始的整数
int[] array={8,7,4,6,9,10,12};
System.out.pritnln(array); //地址值
System.out.println(array[0]); //8
System.out.println(array[4]); //9
System.out.println(array[6]); //12
9.3.数组的内存图
Java把内存分为栈、堆、方法区主要的三个区域
栈：存储局部变量(定义在方法中的变量)
堆：存储new出来的数据(数组就是new出来的)
方法区：存储字节码相关信息(编译后生成的class文件)
9.4.数组的常见操作
9.4.1.数组的遍历
遍历就是把数组中的元素一个一个的获取出来
int[] array={10,20,30,40};
//array.length: 数组的长度
for(int i=0;i9.4.2.数组元素求和
/*
1.定义一个求和变量sum
2.遍历所有需要求和的数据
3.把需要求和的数据和sum累加
*/
int[] array={10,20,30,40};
int sum=0;
for(int i=0;i9.4.3.数组求最值
/*
打擂台的思路：
1.把数组中0索引元素假设为最大值max(有一个人擂台)
2.遍历其他元素和max进行比较(其他人和擂主比武)
如果其他元素>max，就把其他元素赋值给max(擂主换人)
3.循环结束之后，最终max就是最大值(最终的擂主)
*/
int[] array={8,20,7,29};
//把数组中0索引元素假设为最大值max(有一个人擂台)
int max=array[0];
//遍历其他元素和max进行比较(其他人和擂主比武)
for(int i=1;jmax，就把其他元素赋值给max(擂主换人)
if(array[i]>max){
max=array[i];
}
}
System.out.println("数组中元素的最大值为："+max);
到此,java基础语法已经学习完啦,如有问题评论或者私信博主都可以哦,最后大家一起加油,成为你心中最想成为的那个"猿".