python

Linux 入门

目录：又称为文件夹，是包含所有的文件 路径：是反映目录和文件的位置 文件位置：windows：盘符：\文件夹\文件的avi linux：/home/主文件夹/0520/day01/a

[相对位置]当前目录所在位置为0520 ./day01/a ./：当前文件夹 ../：返回上一层 [绝对位置]

文件：在计算机中一切皆文件 在windows中区分文件可以通过扩展名来区分 .exe 在linux中文件没有扩展名，可以通过颜色区分，也可以通过命令来区分。 file 文件名

在Linux中文件分为（五种六类 ） 普通文件 目录文件 设备文件 字符设备文件 块设备文件 管道文件 链接文件

文件权限 读【r】read 写【w】write 执行【x】execute d rwx rwx rwx 分为三组 第一组，文件的所属用户 第二组，文件的所属组 第三组，其他用户

Linux命令 格式：命令 选项 参数 –help 帮助文档 man 命令（如ls：获取ls命令）

ls 显示当前路径内容 ls -a 显示隐藏 ls -l 以列表方式显示 ls -l -h

pwd 显示当前路径 cd：change 改变路径

touch 创建文件 mkdir 创建文件夹 clear 清空 查看 ls –help man ls（支持上下键）：用man查看 按q退出 f（翻屏）b（回翻） gedit 编辑文件内容 cat 查看文件内容 自动补全 tab history 历史命令 创建文件名以.开头为隐藏内容 !2074 （执行2074对应的命令）

rm 删除文件夹 ls 2* 显示2开头的文件 通配符（正则表达式）：*替换多个 ?替换一个 [12345]（范围里都行）或[1-5] 重定向（把原本显示在屏幕上的内容显示在文件夹内）ls -alh > xxx.txt（一个大于号删掉内容，两个直接在末尾添加） more 分屏查看 cat 一次性显示（q退出 f翻 b回） ls -ath /bin | more 直接分屏显示 ./ 当前路径 .. 返回 ../..（上上层） cd - 回到上一次路径 cd ~ 回到家目录 Ctrl+C 不执行，相当于换行 mkdir A/B/C/D/E -p rmdir 只能删空文件夹 rm -r 删全部文件（可非空） mv 原文件名 新文件名 重命名 ln -s 1.txt 1-softlink.txt 创建1-softlink对1的软链接 ln 1.txt 1-hardlink.txt 创建1-hardlink对1的硬连接 cat 1.txt 2.txt >> xxx.txt 合并文件夹 grep “ntfs” xxx.txt 到xxx.txt查找netfs -n 显示在文件中那一行 -v 显示不包含nefs的内容 grep “^ntfs” xxx.txt 以ntfs开头 grep “$ntfs” xxx.txt 以ntfs结尾 mv 1.txt 2.txt 将1剪切并粘贴到2 cp 1.txt 2.txt 将1辅助并粘贴到2 操作文件夹 -r解决

C program

1.内存分布 可执行文件运行后：分为text（代码区）、data（数据区）和未初始化数据（bss）之外，还增加了栈区、堆区 堆区（先申请 后释放） 栈区（先进后出）

全局静态区：全局区/静态区/常量区（const和字符串常量） extern int a; static int a; “hello world”放在常量区（常量区的数据一旦初始化，不能修改，只读的内存）

1.继承重写函数，在子类中重新定义函数即可 2.继承使用部分基类函数，添加部分新内容，在子类函数中显示调用父类函数Parrent::text(); 3.考虑到基类函数可能被子代重写，在基类函数前加virtual，用于父类对象指针指向子类时 4.析构函数前加virtual 子代继承时先调用父类构造函数，然后子构 子析构 父析构 不显示调用父类构造函数 系统默认调用默认构造函数 5.有头链表的构造

6.插入删除节点 删除：pre->next = cur->next; free(cur); 7.引用必须在定义的时候初始化 int &r = a; 引用后与目标对象绑定，后期不能修改 8.引用的更多用法 1-作为函数参数(传引用和传地址) void test(int &a) 2-作为函数返回值

9.C风格字符串 插入删除拷贝 10.随机时间相关函数 11.拷贝构造函数（构造与赋值） 创建对象时给初值拷贝构造函数被调用 object a = b; 创建对象后给初值，不会调用拷贝构造函数 object a; a = b;

调用父类 :base(other);

12.浅拷贝与深度拷贝 深度拷贝解决复制数据时仅复制指针，未复制数据，对象调用析构函数时两个对象同时清空同一片内存。 13.类的朋友（朋友成员，友元） 在类中，用friend关键字可以将一个全局函数声明为该类的“朋友”，也可以将另一个类声明为该类的“朋友”。 friend void Print(object* p); friend class Something;

一、标准输入输出函数 1.通配符 接收换行结束 可以接收空格scanf(“%[^\n]”, ch)： //char str[100]; scanf(“%s”, str); <<<hello world! //此时str中只存取了hello。 scanf(“%[^\n]”, ch); 2.在scanf获取数据时，建议不要添加任何字符 空格除外 scanf(“%d %d %d”, &a, &b, &c); 3.有限定字符宽度的格式化 scanf(“%1s%2s”, arr1, arr2); scanf(“%4d%4d%4d”, &a, &b, &c);

123422343234 1234 2234 3234 4.屏蔽数据类型 %d 屏蔽数字 %c屏蔽字符 scanf(“%*d%s”, &a); <<<123abc abc

printf： 1-printf(“%4s\n”, “ab”);//ab前两个空格占位 2-printf(“%.4s\n”, “abcdef”);//截取前四个字符abcd

strlen()遇’\0’结束 strcpy(字符串1首地址，字符串2首地址) 将字符串2拷贝到字符串1 如果拷贝成功，函数返回字符串1首地址 如果拷贝失败，函数返回NULL; strncpy(字符串1首地址，字符串2首地址, 拷贝次数) 拷贝不会拷贝\0,需手动添加 5.屏蔽区间之内的字符串 scanf(“%[123456]%c”, &ch);//屏蔽123456 scanf(“%[0-9]%c”, &ch);//屏蔽0-9 scanf(“%[a-z]%c”, &ch); //屏蔽a-z

妖姬妲己 2.gets(): 遇到换行或字符串结束标志停止 puts(): 输出字符串，自带’\n’换行 3.fgets(字符指针， 大小， 输入流(文件流)) //char str[100]; fgets(str, 10, stdin); a.如果输入的大小小于原始指针对应区域的大小，会在字符串输入完成时自动加上\n\0。 b.如果输入的大于等于原始指针对应区域的大小，不会加\n，只加\0;

1- 栈操作（先进后出） var arr = [1,2,3] arr.push(4) //参数可以有多个，天下到数组的最后，返回值为数组的长度 pop 返回数组中最后的一个元素，并且会修改数组的长度,数组长度-1

2- 队列操作（先进先出） push() shift() 取出数组中的第一元素，修改数组的长度 unshift() 在数组最前面插入项，返回数组的长度

5-排序方法 reverse() 返回翻转数组 sort() 直接在原数组上进行排序（原数组被取代），默认情况下的sort是对字符编码 从小到大排序， arr.sort(compareFunctions) arr.sort(function(a,b) { return a-b; //a-b<0 从小到大排序？ })

从四位数中取出各项(abcd) a = abcd/1000 b = abcd/100%10 c = abcd/10%10 d = abcd%10

5. 6. 7.

Python

1.字符串 Python把0、空字符串’’和None看成 False，其他数值和非空字符串都看成 True 2.list方法 append()总是把新的元素添加到 list 的尾部 insert()接受两个参数，第一个参数是索引项，第二个参数是待添加的新元素 pop()删掉list的最后一个元素，返回这 个元素 3.tuple 元组（创建完无法修改,用()代替了[]，能访问无法修改） t = (‘Adam’, ‘Lisa’, ‘Bart’) t = (1,) #打印内容：(1,) t = (1) #打印内容：1 4.if语句 if age >= 18: print ‘your age is’, age print ‘adult’ print ‘END’ 5.if-else if age >= 18: print ‘adult’ else: print ‘teenager’ 6.避免嵌套结构的if-else，可以是会用多个if-elif-else if age >= 18: print ‘adult’ elif age >= 6: print ‘teenager’ elif age >= 3: print ‘kid’ else: print ‘baby’ 7.for循环，遍历list和tuple L = [‘Adam’, ‘Lisa’, ‘Bart’] for name in L: print name 8.while循环 N = 10 x = 0 while x < N: print x x = x + 1 9.break sum = 0 x = 1 n = 1 while True: sum += x x *= 2 n += 1 if n > 20: break print sum 10.continue sum = 0 x = 1 while True: sum = sum + x x = x + 1 if x > 100: break print sum 11.多重循环 对100以内的两位数，请使用一个两重循环打印出所有十位数数字比个位数数字小的数，例如，23（2 < 3）。 for x in [1, 2, 3, 4, 5, 6, 7, 8, 9]: for y in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]: if x < y: print x * 10 + y 12.dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } 花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。 由于dict也是集合，len() 函数可以计算任意集合的大小 >>> len(d) 3 13.访问dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } >>> print d[‘Adam’] #使用 d[key] 的形式来查找对应的 value 95

dict的get方法: 在Key不存在的时候，返回None
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None

14.dict特点 dict查找速度快，但占内存 无序、作为key的元素必须不可变、key不可重复 但list是可变的，就不能作为key list查找速度慢，但不占内存 15.更新dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } #要把新同学’Paul’的成绩 72 加进去，用赋值语句： >>> d[‘Paul’] = 72 {‘Lisa’: 85, ‘Paul’: 72, ‘Adam’: 95, ‘Bart’: 59} 已存在key，直接把value替换到原来的 16.遍历dict >>> d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } >>> for key in d: … print key … Lisa Adam Bart 17.set set的元素没有重复，且是无序

25.函数 abs 绝对值函数 cmp(x, y)比较函数 x < y 返回-1; x == y 返回0; x > y 返回1 int()函数把其他数据类型转换为整数 str()函数把其他类型转换成str sum()函数接受一个list作为参数，并返回list所有元素之和。 range() L = [] x = 1 while x <= 100: L.append(x * x) x += 1 print sum(L) 26.编写函数 def my_abs(x): if x >= 0: return x else: return -x

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。
return None可以简写为return。

27.函数返回多值（返回的是tuple） import math def move(x, y, step, angle): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny 28.递归函数（函数内部调用自身） n! 例：fact(n) = n * fact(n - 1) 使用递归函数需要注意防止栈溢出 29.默认参数 int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。 pow(5)默认计算5的平方 #请定义一个 greet() 函数，它包含一个默认参数，如果没有传入，打印 ‘Hello, world.’，如果传入，打印 ‘Hello, xxx.’ def greet(name = ‘world’): print ‘Hello, ‘ + name + ‘.’

greet()
greet('Bart')

30.定义可变参数 可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。 #请编写接受可变参数的 average() 函数。 def average(*args): sum = 0.0 if len(args) == 0: return sum for x in args: sum = sum + x return sum / len(args) print average() print average(1, 2) print average(1, 2, 2, 3, 4) 31.切片(Slice)操作符 数为索引 L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。 如果第一个索引是0，还可以省略 L[:]表示从头到尾 L[::2]第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。 把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。 32.对字符串切片 upper() 可以把字符变成大写字母 >>> ‘abc’.upper() ‘ABC’ #设计一个函数，它接受一个字符串，然后返回一个仅首字母变成大写的字符串。 def firstCharUpper(s): return s[0].upper() + s[1:]

print firstCharUpper('hello')
print firstCharUpper('sunday')
print firstCharUpper('september')

33.迭代 注意: 集合是指包含一组元素的数据结构，已经介绍的包括： 1. 有序集合：list，tuple，str和unicode； 2. 无序集合：set 3. 无序集合并且具有 key-value 对：dict

报错类型 TypeError：传入参数数量不对或传入参数不能被函数所接受 take exactly one argument 负数如何储存

type(name) #获取变量类型 input() #获取用户输入 返回用户输入的字符串 int() float() #类型转换函数 python区分标识符大小写 1.python使用随机数 import random random.randint(10, 20) #大于等于10小于等于20的整数 2.print输出内容结束之后，不会换行 print(“*”, end=””) print(“*”, end=”—“) 3. 1-增加 append insert extend append() 向列表追加数据 insert(index, object) 在列表的指定索引处插入数据 extend() 将其他列表的完整内容追加到当前列表末尾 example: temp_list = [“hello”, “world”, “123”] list = [“900010”, “654”] list.extend(temp_list) 2-删除 remove clear pop pop() a- pop() 默认可以把列表的最后一个元素删除 b- pop(2) 可以指定要删除元素的索引 clear() 清空列表 remove(“hello”) 可以从列表中删除指定的数据 del list[1] 3-统计 len(list) 统计列表中元素总数 list.count(“hello”) 统计列表中某一数据出现的次数 4-排序 1- list.sort() #升序 2- list.sort(reverse = true) #降序 3- list.reverse() #逆序

4.dict无remove() 字典长度 len(temp_dict) 合并字典 main_dict.update(temp.dict) 清空字典 clear() 5.字符串 str = “hello hello” print(str[6]) 1- len函数 统计字符串的长度 len(str) 2- count() 统计某一小字符串出现的次数 str.count(llo) 若没有找到小字符串 返回0，不报错 3- index() 判断子字符串出现的位置 str.index(“llo”) 若没有找到小字符串，报valueError：substring not found 6.TODO注释 # TODO(开发人员) XX任务

1.十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2 True、False 布尔值可以用and、or和not运算。 and or not 空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。 Python还提供了列表、字典等多种数据类型 2.print会依次打印每个字符串，遇到逗号“,”会输出一个空格 #开头注释 3.python为动态语言，不固定变量类型（字符串创建过程） 4.Python中raw字符串与多行字符串 r’’’**’’’（去除转义符） 5.Unicode编码 #-- coding: utf-8 -*- u’’’第一行 第二行’’’ 6.Python中布尔类型 把0、空字符串’’和None看成 False，其他数值和非空字符串都看成 True 布尔计算遵循短路计算 7.list（有序集合） [‘Michael’, ‘Bob’, ‘Tracy’] list中包含的元素并不要求都必须是同一种数据类型 L = [‘Adam’, 95.5, ‘Lisa’, 85, ‘Bart’, 59] a.倒序访问倒数第一L[-1] b.添加新元素 append()总是把新的元素添加到 list 的尾部。 list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素： c.删除 pop()方法总是删掉list的最后一个元素，并且它还返回被删除的元素 pop(2)删除索引为2的元素 list.pop(index) === print list.pop(index) 8.tuple（数组） tuple一旦创建完毕，就不能修改了。用( )替代了[ ]，可以索引访问。

t(1)    ()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 
1，导致我们得到的不是tuple，而是整数 1。所以 Python 规定，单元素 tuple 要多加一个逗号“,”
Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

9.“可变”的tuple t = (‘a’, ‘b’, [‘A’, ‘B’]) L = t[2]

L[0] = ‘X’ L[1] = ‘Y’ print t (‘a’, ‘b’, [‘X’, ‘Y’]) 10.if语句 age = 20 if age >= 18: print ‘your age is’, age print ‘adult’ print ‘END’

#if-else语句 if age >= 18: print ‘adult’ else: print ‘teenager’ #避免多层嵌套 if age >= 18: print ‘adult’ elif age >= 6: print ‘teenager’ elif age >= 3: print ‘kid’ else: print ‘baby’

1. for循环 L = [‘Adam’, ‘Lisa’, ‘Bart’] for name in L: print namename 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素， #并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）。 #———————————- L = [75, 92, 59, 68] sum = 0.0 for x in L: sum += x print sum / 4

12.while循环 N = 10 x = 0 while x < N: print x x = x + 1

13.break sum = 0 x = 1 while True: sum = sum + x x = x + 1 if x > 100: break print sum

13.continue for x in L: if x < 60: continue sum = sum + x n = n + 1

14.多重循环 for x in [‘A’, ‘B’, ‘C’]: for y in [‘1’, ‘2’, ‘3’]: print x + y

15.dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } #我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。 #花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。 #由于dict也是集合，len() 函数可以计算任意集合的大小 a.访问dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } >>> print d[‘Adam’] 95 #使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key： 注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。 要避免 KeyError 发生，有两个办法： 一是先判断一下 key 是否存在，用 in 操作符： if ‘Paul’ in d: print d[‘Paul’] 如果 ‘Paul’ 不存在，if语句判断为False，自然不会执行 print d[‘Paul’] ，从而避免了错误。 二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None: >>> print d.get(‘Bart’) 59 >>> print d.get(‘Paul’) None b.dict特点 1-查找速度快，而list的查找速度随着元素增加而逐渐下降。 2-dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。 3-由于dict是按 key 查找，所以，在一个dict中，key不能重复。 4-dict存储的key-value序对是没有顺序的！这和list不一样： d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } >>> print d {‘Lisa’: 85, ‘Adam’: 95, ‘Bart’: 59} 5-dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的， 都可以作为 key。但是list是可变的，就不能作为 key。最常用的key还是字符串，因为用起来最方便。 c.更新dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } >>> d[‘Paul’] = 72 #如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value。 d.遍历dict d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 } for key in d: print key, ‘:’, d[key]

16.set

s = set([‘A’, ‘B’, ‘C’]) print s set([‘A’, ‘C’, ‘B’]) 18.函数 def my_abs(x): if x >= 0: return x else: return -x #return None可以简写为return。

19.切片 >>> L = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’] #L[0:3]:从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。 #如果第一个索引是0，还可以省略： >>> L[:3] [‘Adam’, ‘Lisa’, ‘Bart’] #只用一个 : ，表示从头到尾： >>> L[:] [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’] 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。 >>> L[::2] [‘Adam’, ‘Bart’]

对于list，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片，试试：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[-2:]
['Bart', 'Paul']
>>> L[:-2]
['Adam', 'Lisa']
>>> L[-3:-1]
['Lisa', 'Bart']
>>> L[-4:-1:2]
['Adam', 'Bart']
记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

字符串有个方法 upper() 可以把字符变成大写字母：
>>> 'abc'.upper()
'ABC'

20.迭代

1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict

1.range()函数 步长step 2.生成器 generate() 3.字符串拼接最优化 array.push(‘

• ‘ +num[i]+’

‘)

str = array.join(‘’)

4.动态创建标签

1-document.write()

2-element.innerHTML

3-document.creatElement(‘div’)

var div = document.creatElement(‘div’)

p.innerText = ‘hello’

p.style.color = red

box.appendChile(div)

1.十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2 True、False 布尔值可以用and、or和not运算。 and or not 空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。 Python还提供了列表、字典等多种数据类型 2.print会依次打印每个字符串，遇到逗号“,”会输出一个空格 #开头注释 3.python为动态语言，不固定变量类型（字符串创建过程） 4.Python中raw字符串与多行字符串

forEach方法

IE8及以下不支持

arr.foreach(function (value, index, obj){})

第一个参数是值，第二个参数是索引，第三个参数是正在遍历的数组

正则表达式

JAVA 笔记

标识符

• 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是任何字符的组合
• 关键字不能用作标识符
• 标识符是大小写敏感的变量 局部变量 类变量（静态变量） 成员变量（非静态变量） Java枚举（5.0以后推出) 枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。 例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。源文件声明规则 当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个public类 一个源文件可以有多个非public类

源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。 如果一个类定义在某个包中，那么package语句应该在源文件的首行。 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。 import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。 类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍。

除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。

基本数据类型

• 内置数据类型-8种
  • 六种数据类型
    • byte
    • short
    • int
    • long
    • float
    • double
  • 一种字符类型
    • char
  • 一种布尔型
    • boolean
• 引用数据类型 所有引用类型的默认值都是null，一个引用变量可以用来引用与任何与之兼容的类型。
  • 数组
  • 对象

JAVA 常量

在Java中用final标志，声明方式和变量类似, 通常使用大写字母表示常量。

final double PI = 3.1415927;

访问修饰符不能用于局部变量

Java 修饰符

• 访问修饰符
• 非访问修饰符 修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) {}
• 访问控制修饰符 可以使用访问控制符来保护对类、变量、方法和构造方法的访问。
  • 默认的，也称为default，在同一包内可见，不使用任何修饰符。
  • 私有的，以private修饰符指定，在同一类内可见。
  • 公有的，以public修饰符指定，对所有类可见。
  • 受保护的，以protected修饰符指定，对同一包内的类和所有子类可见。