编程语言的三大发展阶段：面向机器语言、面向过程语言、面向对象语言 ；
 
其中面向对象语言主要体现三个特征：封装性、继承、动态 ；
 
类的定义：类声明和类体。基本格式如下：
 
class 类名{
 
   类体
 
}
 
特点：
 
1、类是Java程序的基本要素，一个Java应用程序就是由若干个类所构成；
 
2、类声明的变量称为对象变量，也简称 对象 ；
 
3、class 关键字是用来定义类 ；
 
4、类的目的是抽象出一类事物共有的属性和行为，并用一定的语法格式来描述所抽象出的属性和行为；
 
4、类名必须是合法的Java标识符；
 
Java标识符详细说明：（以及中文标识符的说明）
 
https://blog.csdn.net/LagerSwan/article/details/104081548
 

类的声明：
 
如下所示：
 
class Number {
 
.....
 
}
 
class 数字 {
 
.....
 
}
 
其中 class Number 与 class 数字 称为类的声明，而 Number 和 数字 则为类名 ；
 

类体，即 { } 中的内容：
 
类体的内容由如下两部分构成：
 
变量的声明：用来存储属性的值 ；（体现了对象的属性）
方法的定义：方法可以对类中声明的变量进行操作；（体现了对象的行为）
如下代码演示：
 
public class Class_Test {
	int number = 10;
	double numberd = 11.111;
	double TestDouble() {
		double numbers = 100 ;
		numbers += numberd;
		return numbers;
	}
	public static void main(String[] args) {
		Class_Test test = new Class_Test();
		System.out.println(test.TestDouble());
	}
}
 
在以上代码中，声明了一个类 Class_Test ，两个变量 number 与 numberd ，一个方法 TestDouble() ，一个主方法 main () ;
 

成员变量的定义：
 
一、成员变量的类型：
 
成员变量的类型可以是Java中的任何一种数据类型，包括了基本数据类型：整形、浮点型、逻辑类型、字符类型 ；引用类型中的：数组、对象和接口；   
 
如下代码演示：
 
public class Class_Test {

	public static void main(String[] args) {
		
		//成员变量的说明
		//基本数据类型的成员变量
		int testt = 11 ;
		float testf = 11.111f ;
		double testd = 11.11111 ;
		//引用类型的变量
		int a [] ;
		Class_Test test ;
		
	}
}
 
在以上代码中，成员变量：testt，testf，testd 是基本数据类型的变量；a [ ] ，test是引用类型的变量，a [ ] 为数组的变量，test 为类声明的变量，即类对象；
 
二、成员变量的有效范围：
 
成员变量在整个类内都是有效的，其有效性与它在类体中声明的先后位置是不关的；
 
如下代码演示：   最终输出： 110
 
public class Class_Test {
	
	//成员变量的有效范围：
	int number = 11 ;
	int Int_Test(){
		int int1 = number * digit ;
		return int1;
	}
	int digit = 10 ;

	public static void main(String[] args) {
		//类体的说明
		Class_Test test = new Class_Test();
		System.out.println(test.Int_Test());	
	}
}
 
不建议大家这样编写程序，当代码量多时，对代码的可读性有一定的影响，建议先声明成员变量，再定义方法；
 
三、成员变量的编写风格：
 
建议大家在声明成员变量时，变量的名字使用驼峰规则，即变量名由多个单词组成时，从第二个单词开始的其他单词的首字母大学；如：computerArea 、ClassExceptionShow 
 

方法的使用：
 
在类体中，方法的定义包括两部分：方法头、方法体 ；  一般格式如下：
 
方法头 {
 
   方法体
 
}
 
一、方法头说明
 
方法头由方法的类型、名称、名称后面的 （） 以及 （）里面的参数列表所构成；
 
如下代码演示：
 
//无参数的方法头
double testd (){
    return 11.111;
}

//有参数的方法头, x 和 y 即为参数
double testd (double x,double y){
    return x+y;
}
 
二、方法体说明：
 
方法体即 方法（）后面的 { } 以及 { } 里面的内容；
 
在方法体中声明的变量为局部变量，而不是成员变量，局部变量只在方法体内有效，而且与声明时的前后位置有关；
 
如下代码演示：
 
double testd = 10 ;
double testd (double x,double y){      //参数 x，y是局部变量
   double sum;                         //参数 sum 是局部变量
   sum = x + y ;

   if(sum>x){
       sum += testd ;         //参数 testd 是成员变量（全局变量）
}

    return sum;        //return 语句，返回 sum 的值
}
 
局部变量的介绍：
 
1、局部变量不同与成员变量，局部变量只在方法中有效，而且与其声明的位置顺序有关；
 
2、若局部变量声明在一个复合语句中，那么该局部变量的有效范围只在复合语句中有效；
 
double testd (double x,double y){      //参数 x，y是局部变量
	   double sum;                         //参数 sum 是局部变量
	   sum = x + y ;
	   if(sum != 0){
	       int ints = 1;        // ints 为复合语句中的局部变量
	       sum += ints ;
	}
        double bottom = 1.1;
        bottom += ints ;         //程序报错：ints cannot be resolved to a variable
	    return sum;
	}
 
3、若局部变量声明在一个循环语句中，那么该局部变量的有效范围只在循环语句中有效；和以上复合语句是一样的；
 

总结：成员变量与局部变量的区别
 
1、局部变量不同与成员变量，局部变量只在方法中有效，而成员变量在整个类中都有效；
 
2、局部变量与其声明的位置顺序有关，而成员变量与其声明的位置顺序无关；
 
3、若局部变量的名字和成员变量的名字相同，那么成员变量会被隐藏，即在方法体中成员变量暂时是无效的，如下代码演示：
 
class Test_Variable {
    int x = 10 , y ;
   void tests () {
      int x = 5 ;
      y = x + 10 ; //y的值为 15 ，而不是20，此时成员变量 x = 10 在该方法体中，暂时失效；
   }

}
 
4、当想使用方法中被隐藏的成员变量，可以使用关键字 this 进行调用，如下代码演示：
 
class Test_Variable {
    int x = 10 , y ;
   void tests () {
      int x = 5 ;
      y = this.x + 10 ; //此时 y 的值为 20 ，而不是15，this.x调用的为成员变量 x = 10 ;
   }

}
 
5、成员变量有默认值，而局部变量没有默认值，因此在使用局部变量时，要确保该局部变量是有初始值的，否则程序报错；
 
class Test_Variable {

           int  y ;
	   void tests () {
	      int x;       //报错：The local variable x may not have been initialized
	      y = x + 10 ; 
	   }

}
 
 
 
 
 
 

条件：
 1.变量名可以由字母，数字或下划线组成
 2.变量名只能以字母或下划线开头
 例：
 s = ‘hello@’
 1.判断变量名的第一个元素是否为字母或下划线: s[0]
 2.如果第一个元素符合条件，判断除了第一个元素的其他元素:s[1:]
 
for循环：依次遍历字符串的每一个元素
#for i in 'hello':
#	if i.isalpha():
#		print(i)

"""
1.变量名的第一个字符是否为字母或下划线
2.如果是，继续判断（4）
3.如果不是，报错，不合法
4.依次判断除了第一个字符之外的其他字符
5.判断这个字符是否为数字或下划线
"""

while True:
	s = input('变量名：')
	if s == 'exit':
		print('欢迎下次使用')
		break
	if s[0].isalpha() or s[0] == '_':
		for i in s[1:]:
			if not(i.isalnum() or i =='_'):
				print('%s变量名不合法' %(s))
				break
		else:
			print('%s变量名合法' %(s))				
	else:
		print('变量名不合法')

一、定义一个变量
 
Scala在首次定义一个变量时，必须在变量名前面添加关键字“var”或者“val”。用“var”修饰的变量，可以重新赋予新的值，并且把原值抛弃，类似于Java的非final变量。在后续重新赋值时，就不用再写“var”了。而用“val”修饰的变量，则禁止被重新赋值，类似于Java的final变量，换句话说，就是只能读不能写的变量。
 
变量名可以是任意的字母、数字和下划线的组合，但是不能以数字开头。Scala推荐的命名方法是“驼峰命名法”，即每个单词的首字母大写，并且变量名和函数名以小写字母开头，类、对象和特质则以大写字母开头。例如，“val isOne”，“class MyClass”。在首次定义变量时，就必须赋予具体的值来初始化。不能出现如下形式：
 
 
 
val x
 
 
x = 1
 
 
以下代码都是合法的变量定义：
 
 
 
scala> val x = 1
 x: Int = 1
 
 
scala> var y = 2
 y: Int = 2
 
 
scala> val msg = "Hello, world!"
 msg: String = Hello, world! 
 
 
var类型的变量在重新赋值时，新值必须和旧值是同一个类型，否则会发生类型匹配错误：
 
 
 
scala> var x = 1
 x: Int = 1
 
 
scala> x = 10
 x: Int = 10
 
 
scala> x = "abc"
 <console>:12: error: type mismatch;
  found   : String("abc")
  required: Int
        x = "abc"
            ^
 
 
val类型的变量则直接禁止重新赋值：
 
 
 
scala> val x = 1
 x: Int = 1
 
 
scala> x = 10
 <console>:12: error: reassignment to val
        x = 10
          ^
 
 
如果要赋给多个变量相同的值，那么没必要逐条定义，而是在一条语句里用逗号间隔的变量名。例如：
 
 
 
scala> val a, b, c = 1
 a: Int = 1
 b: Int = 1
 c: Int = 1
 
 
Scala的变量定义具有覆盖性，也就是说，如果出现了同名的变量，则后出现的变量会覆盖前面的变量。例如：
 
 
 
scala> val x = 1
 x: Int = 1
 
 
scala> val x = 10
 x: Int = 10
 
 
scala> x
 res0: Int = 10
 
 
要注意的是，赋给变量的对象存在可变与不可变之分。要理解到底是变量指向的对象本身发生了改变，还是变量指向了新的对象。即使是val类型的变量，也能被赋予一个可变对象。这个可变对象能够被重新修改，例如，给可变映射添加新的键值对。事实上，这只是旧对象发生了改变，并未产生新的对象。
 
Scala提倡定义val类型的变量，因为它是函数式编程，而函数式编程的思想之一就是传入函数的参数不应该被改变。所以，在Scala里，所有函数的参数都必须是val类型的。但是，Scala也允许指令式编程，因而预留了var类型的变量，尽管并不推荐使用。对于习惯了指令式编程的读者，例如，喜欢编写“for(i = 0; i < N; i++)”来实现一个循环，很显然更倾向于使用var类型的变量，因为在这个for循环里，变量i被多次重新赋值。Scala推荐读者学会使用val，学会函数式编程。笔者也是学习C/C++出身的，但是现在已经完全习惯了函数式编程。使用val类型的一个好处就是，你不用去计算某个变量在某个时刻是什么值，因为val类型的变量一旦被初始化，就一直不变，直到被重新定义。
 
二、Scala的基本类型
 
Scala是静态语言，在编译期间会检查每个对象的类型。对于类型不匹配的非法操作，在编译时就能被发现。对于动态语言而言，这种非法操作需要等到运行时才能被发现，此时可能造成严重错误。所以，静态语言相比诸如Python这样的动态语言在某些方面是有优势的。对于Chisel而言，我们就需要这种优势。因为Chisel需要编译成Verilog，我们不能产生非法的Verilog语句并且等到模块运行时才去发现它。
 
Scala标准库定义了一些基本类型，如下表所示。除了“String”类型是属于java.lang包之外，其余都在Scala的包里。
 

  Scala的基本类型
 
Byte
8-bit有符号整数，补码表示，范围是  到 
Short
16-bit有符号整数，补码表示，范围是  到 
Int
32-bit有符号整数，补码表示，范围是  到 
Long
64-bit有符号整数，补码表示，范围是  到 
Char
16-bit字符，Unicode编码，范围是 0 到 
String
字符串
Float
32-bit单精度浮点数，符合IEEE 754标准
Double
64-bit双精度浮点数，符合IEEE 754标准
Boolean
布尔值，其值为true或者false
事实上，在定义变量时，应该指明变量的类型，只不过Scala的编译器具有自动推断类型的功能，可以根据赋给变量的对象的类型，来自动推断出变量的类型。如果要显式声明变量的类型，或者无法推断时，则只需在变量名后面加上一个冒号“ : ”，然后在等号与冒号之间写出类型名即可。例如：
 
 
 
scala> val x: Int = 123
 x: Int = 123
 
 
scala> val y: String = "123"
 y: String = 123
 
 
scala> val z: Double = 1.2
 z: Double = 1.2
 
 
   Ⅰ、整数字面量
 
整数有四种类型，默认情况下推断为Int类型。如果字面量的结尾有l或者L，则推断为Long类型。此外，Byte和Short则需要定义变量时显式声明。注意，赋给的字面值不能超过类型的表示范围。
 
整数字面量默认是十进制的，但如果以“0x”或者“0X”开头，则字面量被认为是十六进制。十六进制的字母不区分大小写。例如：
 
 
 
scala> val a = 100
 a: Int = 100
 
 
scala> val b = 0X123Abc
 b: Int = 1194684
 
 
scala> val c: Byte = 200
 <console>:11: error: type mismatch;
  found   : Int(200)
  required: Byte
        val c: Byte = 200
                      ^
 
 
scala> val d = 200L
 d: Long = 200
 
 
  Ⅱ、浮点数字面量 
 
浮点数的字面量都是十进制的，类型默认是Double类型。可以增加一个字母“e”或者“E”，再添加一个整数作为指数，这样就构成10的n次幂。最末尾可以写一个“f”或者“F”，表示Float类型；也可以写一个“d”或者“D”，表示Double类型。注意，Double类型的字面量不能赋给Float类型的变量。虽然Float允许扩展成Double类型，但是会发生精度损失。例如：
 
 
 
scala> val a = 1.2E3
 a: Double = 1200.0
 
 
scala> val b = -3.2f
 b: Float = -3.2
 
 
scala> val c: Float = -3.2
 <console>:11: error: type mismatch;
  found   : Double(-3.2)
  required: Float
        val c: Float = -3.2
                       ^
 
 
scala> val d: Double = -3.2F
 d: Double = -3.200000047683716
 
 
  Ⅲ、字符与字符串字面量
 
 字符字面量是以单引号' '包起来的一个字符，采用Unicode编码。也可以用'\u编码号'的方式来构造一个字符，而且Unicode编码可以出现在代码的任何地方，甚至是名称命名。此外，还支持转义字符。例如：
 
 
 
scala> val a = 'A'
 a: Char = A
 
 
scala> val b = '\u0041'
 b: Char = A
 
 
scala> val c = '\u0042'
 c: Char = B
 
 
scala> val \u0041\u0042 = 1
 AB: Int = 1
 
 
scala> val d = '\\'
 d: Char = \
 
 
字符串就是用双引号" "包起来的字符序列，长度任意，允许掺杂转义字符。此外，也可以用前后各三个双引号"""  """包起来，这样字符串里也能出现双引号，而且转义字符不会被解读。例如：
 
 
 
scala> val a = "\\\\\\"
 a: String = \\\
 
 
scala> val b = """So long \u0041 String \\\'\"!"""
 b: String = So long A String \\\'\"!
 
 
  Ⅳ、字符串插值
 
Scala包括了一个灵活的机制来支持字符串插值，这使得表达式可以被嵌入在字符串字面量中并被求值。第一种形式是s插值器，即在字符串的双引号前加一个s，形如s“…${表达式}…”。s插值器会对内嵌的每个表达式求值，对求值结果调用内置的toString方法，替换掉字面量中的表达式。从美元符号开始到首个非标识符字符(字母、数字、下划线和操作符的组合称为标识符，以及反引号对` `包起来的字符串)的部分会被当作表达式，如果有非标识符字符，就必须放在花括号里，且左花括号要紧跟美元符号。第二种形式是raw插值器，它与s插值器类似，只不过不识别转义字符。第三种形式是f插值器，允许给内嵌的表达式加上printf风格的指令，指令放在表达式之后并以百分号开始。指令语法来自java.util.Formatter。如：
 
 
 
scala> val name = "ABC"
 name: String = ABC
 
 
scala> println(s"$name DEFG")
 ABC DEFG
 
 
scala> s"Sum = ${1 + 10}"
 res0: String = Sum = 11
 
 
scala> s"\\\\"
 res1: String = \\
 
 
scala> raw"\\\\"
 res2: String = \\\\
 
 
scala> printf(f"${math.Pi}%.5f")
 3.14159
 
 
三、总结
 
本章介绍了Scala定义变量的方法及基本变量类型，重点在于学会使用val类型的变量。
 
 
 
上一章   Scala入门——让你的代码跑起来
 
下一章   Scala基础——函数及其几种形式

返回本章节
 
返回作业目录
 

需求说明：
 
编写 Java 程序，定义 Java 类 Point 用来表示坐标，坐标范围在（0,0）到（100，100）以内，并显示合法的坐标在控制台。
 
 
 
 
实现思路：
 
定义 Point 类，为该类分别定义两个属性 X 和 Y，用来表示横坐标和纵坐标。
 
为 Point 类定义两个构造方法，分别是无参构造方法和有参构造方法。
 
在有参构造方法中完成对参数的判定，如果不满足坐标范围则给出错误提示且给坐标一个（1，1）初始坐标，如果参数符合标准，则完成对属性 X 和 Y 的赋值。
 
定义 Point 类的 show 方法，完成 X 和 Y 的打印。
 
实现代码：
 
 
public class Point {
	int x;
	int y;
	
	public Point(int a,int b) {
		if((a >= 0 && a <= 100)&&(b >= 0 && b <= 100)) {
			x = a;
			y = b;
		}else {
			System.out.println("横坐标或纵坐标的取值不符合规范");
			x = 1;
			y = 1;
		}
	}
	public void show() {
		System.out.printf("当前的坐标为%d:%d\n",x,y);
	}
	public static void main(String[] args) {
		Point p1 = new Point(88,77);
		p1.show();
		Point p2 = new Point(150,200);
		p2.show();
	}
}