1.关键字

AJava关键字是Java语言保留供内部使用的,如 class 用于定义类。 关键字也可以称为保留字,它们的意思 是一样的。是被系统征用的特殊单词(标识符)，而且是被广大程序员所认知的。

 goto和const作为保留字存在。

类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记

不能使用关键字作为变量名或方法名

2. 标识符

就是给类，接口，方法，变量等起名字的字符序列。用来查找、定位、标明、唯一确认内容。

  ·表示类名的标识符用大写字母开始。如： Man , GoodMan

  ·表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。 eat() , eatFood()

Java 标识符有如下命名规则：

    标识符必须以字母、下划线_ 、美元符开头。

    标识符其它部分可以是字母、下划线“_”、美元符“ ”和数字的任意组合。

    Java 标识符大小写敏感，且长度无限制。

    不可以是Java的关键字 JAVA不采用通常语言使用的ASCII字符集，而是采用unicode这样的标准的国际字符集。因此，这里的字 母的含义：英文、汉字等等。(不建议大家使用汉字来定义标识符！)

合法的标识符

int a = 3;
int _123 = 3;
int $12aa = 3;
int 变量1 = 55;

不合法的标识符

int 1a = 3; //不能用数字开头
int a# = 3; //不能包含#这样的特殊字符
int int = 3; //不能使用关键字

3. 变量(variable)

     我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放 置什么值不确定！

  Java是一种强类型语言，每个变量都必须声明其类型。

     Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

     变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式 为：

type varName [=value] ；

   注意事项：

   每个变量都有类型，类型可以是基本类型，也可以是引用类型。 变量名必须是合法的标识符。       变量声明是一条完整的语句，因此每一个声明都必须以分号结束。 

   变量声明举例

double salary ；
boolean done；
long earthPopulation ；
int age ；

可以在一行中声明多个变量

int i ,j; // both are integer

不提倡这种风格，逐一声明每一个变量可以提高程序可读性

     可以将变量的声明和初始化放在同一行中，例如

int age = 18;
float e = 2.718281828f;

    实例变量（成员变量 member variable）：方法外部、类的内部定义的变量。从属于对象，生命周 期伴随对象始终,如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成 0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false） 静态变量（类变量 static variable）：使用static定义。 从属于类，生命周期伴随类始终，从类加 载到卸载。 (注：讲完内存分析后我们再深入！先放一放这个概念！),如果不自行初始化，他会自动 初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0， 布尔型默认是false）

说明以下的变量分别是什么类型的变量（局部、静态、实例），分别是声明还是定义亦或是其他操作

public class LocalVariableTest {
   public static void main(String[ ] arg) {
   boolean flag = true;
   char c1, c2;
   c1 = '\u0041';
   c2 = 'B';
   int x;
   x = 9;
   int y = x;
   float f = 3.15f;
   double d = 3.1415926;
   }
}

4. 常量(Constant) 常量：

初始化(initialize)后不能再改变值！

public class Constants {
  public static void main(String[] args) {
  final double PI = 3.14;
  // PI = 3.15; //error
  double r = 4;
  double area = PI * r * r;
  double circle = 2 * PI * r;
  System.out.println("area = " + area);
  System.out.println("circle = " + circle);
  }
}

5. 命名规则(规范)

     所有变量、方法、类名：见名知意

     类成员变量：首字母小写和驼峰原则 : monthSalary

     局部变量：首字母小写和驼峰原则

     常量：大写字母和下划线：MAX_VALUE

     类名：首字母大写和驼峰原则: Man, GoodMan

     方法名：首字母小写和驼峰原则: run(), runRun()

   6. 基本数据类型(primitive data type)

       Java是一种强类型语言，每个变量都必须声明其类型。

       Java的数据类型分为两大类：基本类型（primitive type）和引用类型（reference type）

       Java中定义了3类8种基本数据类型

             逻辑型－boolean

             文本型－ char

             数值型－ byte, short, int, long, float, double

 注：引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！

6.1. 整型

    整型用于表示没有小数部分的数值，它允许是负数。

    整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。于此相反，C和 C++程序需要针对不同的处理器选择最有效的整形

 Java 语言整型常数的三种表示形式：

        十进制整数，如：99, -500, 0。

        八进制整数，要求以 0 开头，如：015。

        十六进制数，要求 0x 或 0X 开头，如：0x15 。

Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ ，如：

long a = 55555555; //不出错，在Int表示的范围内(21亿内)。
long b = 55555555555;//不加l出错，已经超过int表示的范围。

Java中没有无符号类型

6.2. 浮点型

 Java 浮点类型常量有两种表示形式

十进制数形式，例如: 3.14 314.0 0.314

long a = 55555555; //不出错，在Int表示的范围内(21亿内)。

long b = 55555555555;//不加l出错，已经超过int表示的范围。

 科学记数法形式，如 314e2 314E2 314E-2

    浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。 如果需要进行不产生舍 入误差的精确数字计算，需要使用BigDecimal类。

   主要理由：由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存 在舍入误差，很多数字无法精确表示(例如0.1)，其结果只能是接近， 但不等于。

   二进制浮点数不能精确的表示0.1,0.01,0.001这样10的负次幂。并不是所有的小数都能可以精确的 用二进制浮点数表示。最好完全避免使用浮点数比较：

double f = 314e2; //31410^2-->31400.0
double f2 = 314e-2; //31410^(-2)-->3.14
float f = 0.1f;
double d = 1.0/10;
System.out.println( f d); //false
float d1 = 423432423f;
float d2 = d1+1;
if(d1 d2){
System.out.println("d1==d2");
}else{
System.out.println("d1!=d2");
}

大数值：

    Java.math下面的两个有用的类：BigInteger和BigDecimal,这两个类可以处理任意长度的数 值,BigInteger实现了任意精度的整数运算,BigDecimal实现了任意精度的浮点运算。

    浮点数使用总结：

       1. 默认是double

        2. 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计 算，需要使用BigDecimal类避免比较中使用浮点数。

6.3. 字符型

   单引号用来表示字符常量。例如 ‘A’ 是一个字符，它与 “A” 是不同的， “A” 表示含有一个字符的字符 串。 

   char 类型用来表示在 Unicode 编码表中的字符。

   Unicode 编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536 个字符；ASCII码占 1个字节，可允许有128个字符，是Unicode编码表中前128个字符。

char eChar = 'a';
char cChar ='中';

    Unicode具有从0到65535之间的编码，他们通常用从 ’\u0000’ 到 ’\uFFFF’ 之间的十六进制值来表示（前 缀为u表示Unicode）

char c = '\u0061';

Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的含义

char c2 = '\n'; //代表换行符 •

 注：以后我们学的String类，其实是字符序列(char sequence)

6.4. boolean类型

   boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不 同。

   boolean 类型用来判断逻辑条件，一般用于程序流程控制 。

   大小占一位，不是一个字节

boolean flag ;
flag = ………;
if(flag) {
// true分支
} else {
// false分支
}

     实践：Less is More！！请不要这样写：if ( is == true && done == false ) ，只有新手才那么写。 对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的==fasle 和 ==true。

声明与定义比较

​ 在某些编程语言里，函数声明和函数定义区分开的，一个函数声明包括提供对函数名，参数的名字（传统上还有参数的类型），但不必给出函数的任何代码，具体的代码通常属于函数定义的范畴。
​ 在声明和定义有区别的语言中，往往是因为函数的定义可能和其声明放在不同的文件中。python将这两者视为一体，函数的子句由声明的标题行以及随后的定义体组成的。

前向引用

和其他高级语言类似python也不允许在函数未声明之前，对其进行引用或者调用。
我们下面给出几个例子来看一下：

def func():
	print("in func()")
	bar()
print(func())
#会报错

修改：现在定义函数bar()在函数func()前给出bar()声明：

#定义函数的前后顺序都可以！
def func():
	print("in func()")
	bar()
def bar():
	print("in bar()")
func()

现在我们可以安全的调用func(),而不会出现任何问题：

func()
in func()
in bar

事实上，我们甚至可以在函数bar()前定义函数func():

def func():
	print("in func()")
	bar()
def bar():
	print("in bar()")

Amazing依然可以很好的运行，不会有前向引用的问题：

func()
in func()
in bar

这段代码是正确的因为即使（在 foo()中）对 bar()进行的调用出现在 bar()的定义之前，但 foo()本身不是在 bar()声明之前被调用的。换句话说，我们声明 foo()，然后再声明bar()，接着调用 foo()，但是到那时，bar()已经存在了，所以调用成功。

注意 ，foo()在没有错误的情况下成功输出了’in foo()’。名字错误是当访问没有初始化的标识符时才产生的异常 。

函数属性

你可以获得每个 pyhon 模块，类，和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,，但是在将这两个模块导入你的程序后，仍然可以使用这两个变量。所以，即使在两个模块中使用了相同的变量名字，这也是安全的，因为句点属性标识对于两个模块意味了不同的命名空间，比如说，在这段代码中没有名字冲突：

import foo, bar
print(foo.x + bar.x) 

函数属性是 python 另外一个使用了句点属性标识并拥有名字空间的领域。

def foo():
	'foo()-- properly created doc string'

def bar():
	pass

bar.__doc__='Oops,forgot the doc str above'
bar.version =0.1

​

#按住shift在空白处打开 执行时在中间加-i
PS C:\Users\asus\Desktop\pythondemo测试\小巷> python -i band.py
>>> foo.__doc__
'foo()-- properly created doc string'
>>>

​ 上面的 foo()中，我们以常规地方式创建了我们的文档字串，比如， 在函数声明后第一个没有赋值的字串。当声明
bar()时， 我们什么都没做， 仅用了句点属性标识来增加文档字串以及其他属性。我们可以接着任意地访问属性。下面是一个使用了交互解释器的例子。（你可能已经发现，用内建函
数 help()显示会比用__doc__属性更漂亮，但是你可以选择你喜欢的方式）

>>> help(foo)
Help on function foo in module __main__:

foo()
    foo() -- properly created doc string

>>> bar.version 
0.1
>>> foo.__doc__
'foo() -- properly created doc string'
>>> bar.__doc__
'Oops, forgot the doc str above'
>>>

注意我们是如何在函数声明外定义一个文档字串。然而我们仍然可以就像平常一样，在运行时刻访问它。然而你不能在函数的声明中访问属性。换句话说，在函数声明中没有’self‘这样的东西让你可以进行诸如_dict_[‘version’] = 0.1 的赋值。这是因为函数体还没有被创建，但之后你有了函数对象，就可以按我们在上面描述的那样方法来访问它的字典。另外一个自由的名字空间！

内部/内嵌函数

在函数体内创建另外一个函数（对象）是完全合法的，这种函数叫做内部/内嵌函数。
最明显的创造内部函数的方法是在外部函数的定义体内定义函数（用def关键字），如在：

def foo():
	def bar():
		print("bar() called.")
	print("foo() called")
	bar()
foo()
bar()

我们将以上代码置入一个模块中，如inner.py,然后运行，我们会得到如下输出：

bar() called.
foo() called
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'bar' is not defined
>>>

http://www.pythontutor.com/visualize.html#mode=edit
将简单的代码拷贝进去，可以查看执行的步骤过程

内部函数一个有趣的方面在于整个函数体都在外部函数的作用域（即是你可以访问一个对象的区域；稍后会有更多关于作用域的介绍）之内。如果没有任何对 bar()的外部引用，那么除了在函数体内，任何地方都不能对其进行调用，这就是在上述代码执行到最后你看到异常的原因

另外一个函数体内创建函数对象的方式是使用lambda 语句。 稍后讲述。如果内部函数的定义包含了在外部函数里定义的对象的引用（这个对象甚至可以是在外部函数之外），内部函数会变成被称为闭包（closure）的特别之物。

函数应用：打印图形和数学计算

函数的嵌套调用；

程序设计的思路,复杂问题分解为简单问题。

• 思考1：编程实现：

  • 写一个函数打印一条横线

  • 打印自定义行数的横线

    举例子说明：

#打印一行方法一
# def foo():
# 	for i in range(5):
# 		dar()
# def dar():
# 	print("-",end=" ")
# foo()

#打印一行方法二：
# def line():
# 	print("-"*15)
# line()

#打印多条横线的方法一：
# def line():
# 	print("-"*15)
# line()
# def lines(n):
# 	for i in range(n):
# 		line()
# lines(5)

#打印多条横线方法二：
def printOneline():
	print("-"*30)

def printNumline(num):
	a=0
#因为prinOneline函数已经完成了打印横线的功能
#只需要多次调用此函数即可
	while a<num:
		printOneline()
		a+=1
printNumline(3)

• 思考2：编程实现
  • 写一个函数求三个数的和
  • 写一个函数求三个数的平均值

参考代码

# 求3个数的和
def sum3Number(a,b,c):
    return a+b+c # return 的后面可以是数值，也可是一个表达式

# 完成对3个数求平均值
def average3Number(a,b,c):

 # 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
 # 即把接收到的3个数，当做实参传递即可
 sumResult = sum3Number(a,b,c)
 aveResult = sumResult/3.0
 return aveResult

 # 调用函数，完成对3个数求平均值
 result = average3Number(11,2,55)
 print("average is %d"%result)

变量作用域

标识符的作用域是定义为其声明在程序的可应用范围，或者即是我们所说的变量可见性，换句话说，就好像在问你自己，你可以在程序里的哪些部分去访问一个制定的标识符，变量可以是局部域或者是全局域。

全局变量与局部变量

定义在函数内的变量有局部作用域，在一个模块中最高级别的变量有全局作用域。
“声明适用的程序的范围被称为了声明的作用域，在一个过程中，如果名字在过程的声明之内，它的出现即为过程的局部变量，否则的话，出现即为非局部的”.
全局变量的一个特征是除非被删除掉，否则它们的存活到脚本运行结束，且对于所有的函数，他们的值都是可以被访问的，然而局部变量，就像它们存放的栈，暂时的存在，仅仅只依赖于定义它们的函数现阶段是否处于活动，当一个函数调用出现时，其局部变量就进入声明它们的作用域，在那一刻，一个新的局部变量名为那个对象创建了，一旦函数完成，框架被释放，变量将会离开作用域。

举例子说明：

global_str='foo'
def foo():
	local_str='bar'
	return global_str+local_str
print(foo())#结果为：foobar
print(global_str)#结果为：foo
print(local_str)#会报错，因为局部变量只能在函数方法内部使用才有用

题目：
编写函数，实现求两个序列的交集。（为方便，序列类型可以直接统一采用列表）
方法一：
def foo():
	a=[1,2,3,4,5]
	b=[2,3,4]
	list1=list((set(a)&set(b)))
	print(list1)
foo()
结果：[2, 3, 4]
方法二：
def foo():
	a=[1,2,3,4,5]
	b=[2,3,4]
	list1=[val for val in a if val in b]
	print(list1)
foo()
结果：[2, 3, 4]

局部变量

例子：

def foo():
	a=666
	print('foo(),修改前a:\t',a)
	a=999
	print('foo(),修改后a:\t',a)

def bar():
	a=8899
	print('bar(),a\t',a)

运行结果：

>>> foo()
foo(),修改前a:   666
foo(),修改后a:   999
>>> bar()
bar(),a  8899
>>>

可以看出：

• 局部变量，就是在函数内部定义的变量
• 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
• 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

全局变量

同样，先看一下例子：

a=6699
def foo():
	print('foo(),a:\t',a)

def bar():
	print('bar(),a:\t',a)
 
print(foo())
print(bar())

运行结果：

foo(),a:	 6699
None
bar(),a:	 6699
None

讨论1:如果全局变量和局部变量名字相同？

a=8899
def foo():
	a=666
	print('foo(),修改前a:\t',a)
	a=888
	print('foo(),修改后a:\t',a)

def bar():
	print('bar(),a:\t',a)

foo()
bar()

运行结果为：

foo(),修改前a:	 666
foo(),修改后a:	 888
bar(),a:	 8899

讨论2：全局变量，是能够在所有的函数中进行使用的变量，那么局部变量可否进行修改编程全局变量？

globa语句

如果将全局变量的名字声明在一个函数体内的时候，全局变量的名字能被局部变量给覆盖掉。

a=6699
def foo():
	global a 

	print('foo(),修改前,a:\t',a)
	a=666
	print('foo(),修改后,a:\t',a)

def bar():
	print('bar(),a:\t',a)
foo()
bar()

运行结果：

foo(),修改前,a:	 6699
foo(),修改后,a:	 666
bar(),a:	 666

通过以上例子，我们可以观察出：

• 在函数外边定义的变量叫做全局变量
• 全局变量能够在所有的函数中进行访问
• 如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
• 如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的

可变类型的全局变量

先举2个例子：

例子1：

a=1
def foo():
	a+=1
	print(a)
foo()#内存地址改变了

运行后：

Traceback (most recent call last):
  File "C:\Users\asus\Desktop\pythondemo测试\小巷\band.py", line 108, in <module>
    foo()
  File "C:\Users\asus\Desktop\pythondemo测试\小巷\band.py", line 106, in foo
    a+=1
UnboundLocalError: local variable 'a' referenced before assignment

例子2：

li=['a','b']
def foo():
	li.append('c')
	print(li)
print(foo())
print(li)

运行结果：

['a', 'b', 'c']
None
['a', 'b', 'c']