小菜鸟之面试题总结只限自己

Oracle基本命令

连接数据库：
使用sql*plus连接oracle
命令方式
1.conn[ect]

用法：conn 用户名/密码@网络服务名[as sysdba/sysoper]

当用特权用户身份连接时，必须带上as sysdba或是as sysoper

远程连接：sqlplus usr/pwd@//host:port/sid 

如：conn sys/admin@127.0.0.1:1521/orcl as sysdba;

2.disc[onnect]

说明: 该命令用来断开与当前数据库的连接

3.psssw[ord]

说明: 该命令用于修改用户的密码，如果要想修改其它用户的密码，

需要用sys/system登录。4.show user

说明: 显示当前用户名

5.exit

说明: 该命令会断开与数据库的连接，同时会退出sql*plus

文件操作命令
1.start和@

说明: 运行sql脚本

案例: sql>@ d:\a.sql或是sql>start d:\a.sql

2.edit

说明: 该命令可以编辑指定的sql脚本

案例: sql>edit d:\a.sql,这样会把d:\a.sql这个文件打开

3.spool

说明: 该命令可以将sql*plus屏幕上的内容输出到指定文件中去。

案例: sql>spool d:\b.sql 并输入 sql>spool off

显示和设置环境变量
概述：可以用来控制输出的各种格式，show all可以显示当前相关的设置

1.linesize

说明：设置显示行的宽度，默认是80个字符

show linesize

set linesize 90

查看当前所有表：

select * from tab;

查询当前日期
select to_char(sysdate,'yyyy-mm-dd,hh24:mi:ss') from dual;

查看本用户下的各种对象的SQL脚本
SQL语句：

表：

　　select * from cat;

　　select * from tab;

　　select table_name from user_tables;

视图：

　　select text from user_views where view_name=upper('&view_name');

索引：

　　select index_name,table_owner,table_name,

tablespace_name,status from user_indexes order by table_name;

触发器：

　　select trigger_name,trigger_type,table_owner,

table_name,status from user_triggers;

快照：

　　select owner,name,master,table_name,last_refresh,

next from user_snapshots order by owner,next;

同义词：

　　select * from syn;

序列：

　　select * from seq;

数据库链路：

　　select * from user_db_links;

约束限制：

　　select TABLE_NAME,CONSTRAINT_NAME,SEARCH_CONDITION,

STATUS from user_constraints;

本用户读取其他用户对象的权限：

　　select * from user_tab_privs;

本用户所拥有的系统权限：

　　select * from user_sys_privs;

用户：

　　select * from all_users order by user_id;

表空间剩余自由空间情况：

　　select tablespace_name,sum(bytes) 总字节数,max(bytes),

count(*) from dba_free_space group by tablespace_name；

数据字典：

　　select table_name from dict order by table_name;

锁及资源信息：

　　select * from v$lock;不包括DDL锁

数据库字符集：

　　select name,value$ from props$ where name='NLS_CHARACTERSET';

inin.ora参数：

　　select name,value from v$parameter order by name;

SQL共享池：

　　select sql_text from v$sqlarea;

数据库：

　　select * from v$database

控制文件：

　　select * from V$controlfile;

重做日志文件信息：

　　select * from V$logfile;

来自控制文件中的日志文件信息：

　　select * from V$log;

来自控制文件中的数据文件信息：

　　select * from V$datafile;

NLS参数当前值：

　　select * from V$nls_parameters;

ORACLE版本信息：

　　select * from v$version;

描述后台进程：

　　select * from v$bgprocess;

查看版本信息：

　　select * from product_component_version;

表空间管理
概述：
Oracle表空间是数据管理的基本方法，所有用户的对象要存放在表空间中，

也就是用户有空间的使用权，才能创建用户对象。否则是不充许创建对象，

因为就是想创建对象，如表，索引等，也没有地方存放，Oracle会提示:没有存储配额。

因此，在创建对象之前，首先要分配存储空间。分配存储，就要创建表空间

Oracle可以创建的表空间有三种类型:

(1)TEMPORARY: 临时表空间，用于临时数据的存放;

创建临时表空间的语法如下:CREATE TEMPORARY TABLESPACE "SAMPLE"。。。。。。

(2)UNDO : 还原表空间。用于存入重做日志文件。

创建还原表空间的语法如下:CREATE UNDOTABLESPACE "SAMPLE"。。。。。。

(3)用户表空间: 最重要，也是用于存放用户数据表空间可以直接写成: 

CREATE TABLESPACE"SAMPLE"TEMPORARY 和 UNDO 表空间是Oracle 

管理的特殊的表空间。只用于存放系统相关数据。

查看表空间的名字和所属文件
select tablespace_name, file_id, file_name,

round(bytes/(1024*1024),0) total_space

from dba_data_files

order by tablespace_name;

创建表空间：
创建表空间名称为：epet_tablespace

表空间的物理文件位置：E:\oracle\product\10.2.0\oradata\JBITDB\EPET.DBF 大小为100M

CREATE TABLESPACE epet_tablespace

DATAFILE 'E:\oracle\product\10.2.0\oradata\JBITDB\EPET.DBF'

SIZE 100M;

修改表空间并为表空间添加物理文件：
ALTER TABLESPACE JIANGWFTABLESPACE ADD DATAFILE 

'E:\PROJECTS\ZHONGHUA\PROJECT\DATABASE\ZHONGHUA\JIANGWFTABLESPACE2.DBF'

size   50m;



ALTER TABLESPACE "TEMPTABLESPACE" ADD DATAFILE 

'E:\PROJECTS\ZHONGHUA\PROJECT\DATABASE\ZHONGHUA\JIANGWFTABLESPACE2.ORA'

SIZE 5M AUTOEXTEND ON NEXT 100K MAXSIZE UNLIMITED

增加表空间大小的四种方法
 Meathod1：给表空间增加数据文件

 ALTER TABLESPACE app_data ADD DATAFILE

 'D:\ORACLE\PRODUCT\10.2.0\ORADATA\EDWTEST\APP03.DBF' SIZE 50M;



 Meathod2：新增数据文件，并且允许数据文件自动增长

 ALTER TABLESPACE app_data ADD DATAFILE

 'D:\ORACLE\PRODUCT\10.2.0\ORADATA\EDWTEST\APP04.DBF' SIZE 50M

 AUTOEXTEND ON NEXT 5M MAXSIZE 100M;



 Meathod3：允许已存在的数据文件自动增长

 ALTER DATABASE DATAFILE 'D:\ORACLE\PRODUCT\10.2.0\

ORADATA\EDWTEST\APP03.DBF'

 AUTOEXTEND ON NEXT 5M MAXSIZE 100M;



 Meathod4：手工改变已存在数据文件的大小

 ALTER DATABASE DATAFILE 'D:\ORACLE\PRODUCT\10.2.0\

ORADATA\EDWTEST\APP02.DBF'

 RESIZE 100M;



修改物理文件大小
alter database datafile 'E:\PROJECTS\ZHONGHUA\PROJECT\

DATABASE\ZHONGHUA\JIANGWFTABLESPACE3.DBF'

resize 10M

修改用户表table的表空间
alter table 表名 move tablespace 新表空间名;

查询所有用户表：
select * from user_tables;

删除表空间：
drop tablespace 表空间名称



移动表至另一表空间
alter table move tablespace room1;

建立临时表空间
CREATE TEMPORARY TABLESPACE temp_data

TEMPFILE '/oracle/oradata/db/TEMP_DATA.dbf' SIZE 50M

设定后查看表空间信息
SELECT A.TABLESPACE_NAME,A.BYTES TOTAL,B.BYTES USED, C.BYTES FREE,

(B.BYTES*100)/A.BYTES "% USED",(C.BYTES*100)/A.BYTES "% FREE"

FROM SYS.SM$TS_AVAIL A,SYS.SM$TS_USED B,SYS.SM$TS_FREE C

WHERE A.TABLESPACE_NAME=B.TABLESPACE_NAME AND A.TABLESPACE_NAME=C.TABLESPACE_NAME;

用户管理：
创建用户
概述：在oracle中要创建一个新的用户使用create user语句，

一般是具有dba(数据库管理员)的权限才能使用。

 语法格式：create user 用户名 identified by 密码;

创建用户
create user EPET

  identified by "BDQN"

  default tablespace "EPET_TABLESPACE"

  temporary tablespace "DIAOCHA_TEMP"

  profile DEFAULT

  ACCOUNT UNLOCK;

给用户赋予某个角色的权限：

grant 角色 to QIUDING;

grant unlimited tablespace to QIUDING

查看当前用户所属角色：
select * from user_role_privs;

查看当前用户的缺省表空间
 select username,default_tablespace from user_users;

查看某用户所拥有的对象：
SELECT owner,object_name, object_type FROM dba_objects WHERE owner= 'EPET';

查看某用户的所有表：
select * from all_tables where owner='SHOPXP';--用户名称为“SHOPXP”的所有表

给用户修改密码
概述：如果给自己修改密码可以直接使用

password 用户名

如果给别人修改密码则需要具有dba的权限，或是拥有alter user的系统权限

alter user 用户名 identified by 新密码

删除用户
概述：一般以dba的身份去删除某个用户，如果用其它用户去删除用户则需要具有drop user的权限。

比如 drop user 用户名 【cascade】

在删除用户时，注意：

如果要删除的用户，已经创建了表，那么就需要在删除的时候带一个参数cascade;



权限说明：

创建的新用户是没有任何权限的，甚至连登陆的数据库的权限都没有，

需要为其指定相应的权限。给一个用户赋权限使用命令grant，回收权限使用命令revoke。



角色管理
1.connect角色
 connect角色具有一般应用开发人员需要的大部分权限，当建立了一个用户后，

多数情况下，只要给用户授予connect和 resource角色就够了，那么connect角色具有哪些系统权限呢？

 alter session

 create table

 create view

 create sequence create cluster

 create database link

 create session

 2.resource角色
 resource角色具有应用开发人员所需要的其它权限，比如建立存储过程，

触发器等。这里需要注意的是 resource角色隐含了unlimited tablespace系统权限。

 resource角色包含以下系统权限：

 create cluster

 create indextype

 create table

 create sequence  create type

 create procedure

 create trigger

3.dba角色
 dba角色具有所有的系统权限，及with admin option选项，

默认的dba用户为sys和system，它们可以将任何系统权限授予其他用户。

但是要注意的是dba角色不具备sysdba和sysoper的特权（启动和关闭数据库）。

 自定义角色.

 顾名思义就是自己定义的角色，根据自己的需要来定义。一般是dba来建立，

如果用别的用户来建立，则需要具有create role的系统权限。

在建立角色时可以指定验证方式（不验证，数据库验证等）。

4：创建角色：
CREATE ROLE "QIUDINGROLE" NOT IDENTIFIED;

把角色赋予某个用户

GRANT "CONNECT" TO "QIUDINGROLE";

GRANT "DBA" TO "QIUDINGROLE";

GRANT "RESOURCE" TO "QIUDINGROLE";

5：给角色授权：
grant select on scott.emp to 角色名;

grant insert, update, delete on scott.emp to 角色名;

6：把某个角色的权限赋予某个用户
grant 角色名 to 用户名称

GRANT DBA TO用户名称;

GRANT resource TO用户名称;

7:显示所有角色
 SQL> select * from dba_roles;

Oracle表的管理
表名和列的命名规则
· 必须以字母开头

· 长度不能超过30个字符

· 不能使用oracle的保留字

· 只能使用如下字符 A-Z，a-z，0-9，$,#等

oracle支持的数据类型
 字符类
char    定长 最大2000个字符。

例子：char(10)  ‘小韩’前四个字符放‘小韩’，后添6个空格补全 如‘小韩      

’ varchar2(20)  变长  最大4000个字符。

例子：varchar2（10） ‘小韩’ oracle分配四个字符。这样可以节省空间。

clob(character large object) 字符型大对象 最大4G

char 查询的速度极快浪费空间，查询比较多的数据用。

varchar 节省空间

数字型
number范围 -10的38次方 到 10的38次方，可以表示整数，也可以表示小数 

：number(5,2)表示一位小数有5位有效数，2位小数

范围：-999.99到999.99

number(5)  表示一个5位整数



范围99999到-99999



日期类型
date 包含年月日和时分秒   oracle默认格式  1-1月-1999

timestamp 这是oracle9i对date数据类型的扩展。可以精确到毫秒。

日期类型相关函数和格式转换函数的使用
获取系统日期：  SYSDATE()

格式化日期：    TO_CHAR(SYSDATE(),'YY/MM/DD HH24:MI:SS)

      或        TO_DATE(SYSDATE(),'YY/MM/DD HH24:MI:SS)

格式化数字：    TO_NUMBER

       注：     TO_CHAR  把日期或数字转换为字符串

                TO_CHAR(number, '格式')

                TO_CHAR(salary, '$99,999.99')

                TO_CHAR(date, '格式')

                TO_DATE  把字符串转换为数据库中的日期类型

                TO_DATE(char, '格式')

                TO_NUMBER  将字符串转换为数字

                TO_NUMBER(char, '格式')

返回系统日期,输出 25-12月-09

select sysdate from dual;

mi是分钟，输出 2009-12-25 14:23:31

select to_char(sysdate,'yyyy-MM-dd HH24:mi:ss') from dual;

mm会显示月份，输出 2009-12-25 14:12:31

select to_char(sysdate,'yyyy-MM-dd HH24:mm:ss') from dual;

输出 09-12-25 14:23:31

select to_char(sysdate,'yy-mm-dd hh24:mi:ss') from dual

输出 2009-12-25 14:23:31

select to_date('2009-12-25 14:23:31','yyyy-mm-dd,hh24:mi:ss') from dual

而如果把上式写作：

 select to_date('2009-12-25 14:23:31','yyyy-mm-dd,hh:mi:ss') from dual

则会报错，因为小时hh是12进制，14为非法输入，不能匹配。

输出 $10,000,00 ：

select to_char(1000000,'$99,999,99') from dual;

输出 RMB10,000,00 ：

select to_char(1000000,'L99,999,99') from dual;

输出 1000000.12 ：

select trunc(to_number('1000000.123'),2) from dual;

select to_number('1000000.123') from dual;

转换的格式：

表示 year 的：y 表示年的最后一位 、

             yy 表示年的最后2位 、

             yyy 表示年的最后3位 、

             yyyy 用4位数表示年

表示month的： mm 用2位数字表示月 、

             mon 用简写形式， 比如11月或者nov 、

             month 用全称， 比如11月或者november

表示day的： dd  表示当月第几天 、

             ddd 表示当年第几天 、

             dy  当周第几天，简写， 比如星期五或者fri 、

             day 当周第几天，全称， 比如星期五或者friday

表示hour的：hh   2位数表示小时 12进制 、

              hh24 2位数表示小时 24小时

表示minute的：mi 2位数表示分钟

表示second的：ss 2位数表示秒 60进制

表示季度的：q 一位数 表示季度 （1-4）

另外还有ww 用来表示当年第几周 w用来表示当月第几周。

24小时制下的时间范围：00：00：00-23：59：59

12小时制下的时间范围：1：00：00-12：59：59

数字格式:  9  代表一个数字

          0  强制显示0

          $  放置一个$符

          L  放置一个浮动本地货币符

          .  显示小数点

          ,  显示千位指示符

补充：

当前时间减去7分钟的时间

select sysdate,sysdate - interval '7' MINUTE from dual;

当前时间减去7小时的时间

select sysdate - interval '7' hour from dual;

当前时间减去7天的时间

select sysdate - interval '7' day from dual;

当前时间减去7月的时间

select sysdate,sysdate - interval '7' month from dual;

当前时间减去7年的时间

select sysdate,sysdate - interval '7' year from dual;

时间间隔乘以一个数字

select sysdate,sysdate - 8*interval '7' hour from dual;

图片
blob 二进制数据 可以存放图片/声音  4G   一般来讲，在真实项目中是不会把图片和声音真的往数据库里存放，一般存放图片、视频的路径，如果安全需要比较高的话，则放入数据库。

创建表的案例
--创建好了表空间和用户student后

--用student用户登录，就可以创建表了

create table grade

(

gradeid number primary key,

name varchar2(29),

location varchar2(30)

)

--create sequence seq_grade increment by 1 start with 1 nomaxvalue nocycle

--nocache;

--create or replace trigger tri_grade before insert on grade for each row

--begin

 -- select seq_grade.Nextval into:new.gradeid from dual;



--end

insert into grade(gradeid,name,location) values(1,'jiangwf','shenzhen');

insert into grade(gradeid,name,location) values(2,'zhulei','shenzhen');

insert into grade(gradeid,name,location) values(3,'jianghaoyu','shenzhen');

select * from grade



create table 学生表

(

学生编号 number primary key,

学生姓名 varchar2(50),

学生地址 varchar2(50)

);



insert into 学生表(学生编号,学生姓名,学生地址) values(1,'jiangwf','shenzhen');

insert into 学生表(学生编号,学生姓名,学生地址) values(2,'zhulei','shenzhen');

insert into 学生表(学生编号,学生姓名,学生地址) values(3,'jianghaoyu','shenzhen');

建一个和a表结构一样的空表
create table b as select * from a where 1=2;

create table b(b1,b2,b3) as select a1,a2,a3 from a where 1=2;

创建序列（名称为：myCus_seq）
CREATE SEQUENCE myCus_seq

START WITH 1

INCREMENT BY 1

NOMAXVALUE

CACHE 10;

SQL编程语法：
循环的语句格式：
declare

x number;

begin

x:=0;

loop

x:=x+1;

if x>=3 then

exit;

end if;

dbms_output.put_line('内部x='||x);

end loop;

dbms_output.put_line('外部x='||x);

end;

/

-------------------------------------------------------------

begin

for i in 1..5 loop

dbms_output.put_line('内部i='||i);

end loop;

dbms_output.put_line('结束');

end;

/

---------------------------------------------------------------

declare

x number;

begin

x:=0;

while x<=3 loop

x:=x+1;

dbms_output.put_line('内部x='||x);

end loop;

dbms_output.put_line('外部x='||x);

end;

/

自定义函数和使用
创建函数
Oracle创建函数（function）
1、基本语法规则如下：

create or replace function (Name in type, Name in type, ...) return number is

  Result number;

begin

  return (Result);

end ;



----例子---------------------------------------------------------------------

 create or replace function getmastername(uid number) return varchar2

 as

 mname varchar2(50);

 begin

 select  loginid into mname from master where master.id=uid;

 return mname;

 end;

案例1：
create or replace function jiangwf.getUserName(userid varchar2)

return varchar2

is

uName varchar2(50);

begin

select nvl(UserName,'') into uName from jiangwf.UserInfo where UserNo=userid;

return uName;

end;



调用函数

select jiangwf.getUserName(UserNo),jiangwf.UserInfo.UserPWD from jiangwf.UserInfo

*********************************************************************************************

案例2：
创建函数

create or replace function jiangwf.getUserPWD(userid varchar2)

return varchar2

is

UserPassWord varchar2(50);

begin

select nvl(UserPWD,'') into UserPassWord from jiangwf.

UserInfo where UserNo=userid;

return UserPassWord;

end;

调用：

select jiangwf.UserInfo.*,jiangwf.getUserPWD(UserNo) 

from jiangwf.UserInfo;



存储过程相关：
1、基本语法
create or replace procedure update_emp_sal

(Name in out type,

 Name in out type, ...

) is

begin



end update_emp_sal;



写一个简单的例子修改emp表的ename字段
create or replace procedure update_emp

(

v_empno  varchar2,

v_ename  varchar2

) is

begin

update emp set ename=v_ename where empno=v_empno;

end update_emp;

调用方法如下：

exec  update_emp('7935','test');

有返回值的存储过程
就写一个简单的返回empno=7935的sal值

create or replace procedure emp_out_sal

 (

 v_empno in varchar2,

 v_sal out number

 ) is

 vsal number(7,2);

 begin

      select sal into vsal from emp where empno=v_empno;

      v_sal:=vsal;

 end;



调用有返回值的过程

var vsal number

exec emp_out_sal('7935',:vsal);

PL/SQL procedure successfully completed

vsal

---------

700

SQL> var vsal number

SQL> call emp_out_sal('7935',:vsal);

Method called

vsal

---------

700

Oracle创建包
概述：
包用于组合逻辑相关的过程和函数，它由包规范和包体两个部分组成。

包规范用于定义公用的常量、变量、过程和函数，创建包规范可以使用CREATE PACKAGE命令，

创建包体可以使用CREATE PACKAGE BODY

1、创建包规范
 create package emp_pkg is

 procedure emp_update_ename(v_empno varchar2,v_ename varchar2);

 function emp_get_sal(v_empno varchar2) return number;

 end;

创建包体

create or replace package body emp_pkg

is

    procedure emp_update_ename

    (

    v_empno varchar2,

    v_ename varchar2

    )

    is

    vename varchar2(32);

    begin

    update emp set ename=v_ename where empno=v_empno;

    commit;

    select ename into vename from emp where empno=v_empno;



    dbms_output.put_line('雇员名称：'||vename);



    end;



    function emp_get_sal

    (

    v_empno varchar2

    )

    return number is

    vsal number(7,2);

    begin

    select sal into vsal from emp where empno=v_empno;

    return vsal;

    end;

end;

在此提示，在没有创建包规范就创建包体，会失败，要使用包，必须先创建包规范

，然后在创建包体

当要调用包的过程和函数时，在过程和函数的名称前加上包名作为前缀（包名.子程序名称），

而如果要访问其他方案的包时需要在包的名称前加上方案的名称（方案名称.包名.子程序名称）

实例：
SQL> var vsla number

SQL> call emp_pkg.emp_get_sal('7935') into :vsal;

Method called

vsal

---------

700

SQL> exec emp_pkg.emp_update_ename('7935','helong');

雇员名称：helong

SQL> call emp_pkg.emp_update_ename('7935','helong');

Method called

SQL> select * from dual;

DUMMY

-----

X

用pl/sql developer导出表结构和数据
1、点击Tools--Export User Objects
    这种方式可以导出当前用户拥有的所有对象，包括表、视图、触发器、同义词等等，

对于表，只能导出表结构，不能导出数据，选中要导出的对象，设置好导出的路径和各个参数后，点击Export就OK

    PS：这种方式还可以导出其他用户的对象，在下面user下拉框中选择要用户就可以，

默认是系统当前登录用户

2、如果想将表中数据一起导出，可用Tools--Export Tables：

这种方式导出的文件，本身就带着创建表结构的sql语句 选中要导出的表（可选多个），

导出方式有三种：

    Oracle Export，Sql Insert，pl/sql developer

 第一种是导出为.dmp的文件：

.dmp文件是二进制的，可以跨平台，还能包含权限，效率也很不错，用得最广

第二种是导出为.sql文件：

可用文本编辑器查看，通用性比较好，但效率不如第一种，适合小数据量导入导出。

尤其注意的是表中不能有大字段（blob,clob），如果有，会提示不能导出，可以用第一种和第三种方式导出。

第三种是导出为.pde格式：

.pde为Pl/sql developer自有的文件格式，只能用Pl/sql developer自己导入导出；

不能用编辑器查看，效率不知道怎么样

PS:只有“Oracle Export”方式导出再导入后，表结构和索引结构没有发生变化，

另两种方式都改变了索引类型。 导入的情况和导出一样

数据库权限管理

权限：

　　create session  允许用户登录数据库权限

　　create table   允许用户创建表权限

　　unlimited tablespace  允许用户在其他表空间随意建表

角色：

　　connect

　　resource

　　dba



　　CONNECT角色： --是授予最终用户的典型权利，最基本的权力，

能够连接到ORACLE数据库中，并在对其他用户的表有访问权限时，做SELECT、UPDATE、INSERTT等操作。
        ALTER SESSION --修改会话
        CREATE CLUSTER --建立聚簇
        CREATE DATABASE LINK --建立数据库链接
        CREATE SEQUENCE --建立序列
        CREATE SESSION --建立会话
        CREATE SYNONYM --建立同义词
        CREATE VIEW --建立视图
       RESOURCE角色： --是授予开发人员的，能在自己的方案中创建表、序列、视图等。
        CREATE CLUSTER --建立聚簇
        CREATE PROCEDURE --建立过程
        CREATE SEQUENCE --建立序列
        CREATE TABLE --建表
        CREATE TRIGGER --建立触发器
        CREATE TYPE --建立类型

　　DBA角色，是授予系统管理员的，拥有该角色的用户就能成为系统管理员了，它拥有所有的系统权限

　　例：

　　#sqlplus /nolog

　　SQL> conn / as sysdba;

　　SQL>create user username identified by password  –username/password都是用户自定义

　　SQL> grant dba to username;

　　SQL> conn username/password

　　SQL> select * from user_sys_privs;

　　我们将从创建Oracle用户权限表开始谈起，然后讲解登陆等一般性动作，

使大家对Oracle用户权限表有个深入的了解。

　　一、创建

　　sys;//系统管理员，拥有最高权限

　　system;//本地管理员，次高权限

　　scott;//普通用户，密码默认为tiger,默认未解锁

　　oracle有三个默认的用户名和密码~
　　1.用户名:sys密码:change_on_install
　　2.用户名:system密码:manager
　　3.用户名:scott密码:tiger
　　二、登陆

　　sqlplus / as sysdba;//登陆sys帐户

　　sqlplus sys as sysdba;//同上

　　sqlplus scott/tiger;//登陆普通用户scott

　　三、管理用户

　　create user zhangsan;//在管理员帐户下，创建用户zhangsan

　　alert user scott identified by tiger;//修改密码

　　四，授予权限

　　1、默认的普通用户scott默认未解锁，不能进行那个使用，新建的用户也没有任何权限，必须授予权限



　　grant create session to zhangsan;//授予zhangsan用户创建session的权限，即登陆权限，允许用户登录数据库

　　grant unlimited tablespace to zhangsan;//授予zhangsan用户使用表空间的权限

　　grant create table to zhangsan;//授予创建表的权限

　　grante drop table to zhangsan;//授予删除表的权限

　　grant insert table to zhangsan;//插入表的权限

　　grant update table to zhangsan;//修改表的权限

　　grant all to public;//这条比较重要，授予所有权限(all)给所有用户(public)

　　2、oralce对权限管理比较严谨，普通用户之间也是默认不能互相访问的，需要互相授权



　　grant select on tablename to zhangsan;//授予zhangsan用户查看指定表的权限

　　grant drop on tablename to zhangsan;//授予删除表的权限

　　grant insert on tablename to zhangsan;//授予插入的权限

　　grant update on tablename to zhangsan;//授予修改表的权限

　　grant insert(id) on tablename to zhangsan;

　　grant update(id) on tablename to zhangsan;

//授予对指定表特定字段的插入和修改权限，注意，只能是insert和update

　　grant alert all table to zhangsan;//授予zhangsan用户alert任意表的权限

　　五、撤销权限

　　基本语法同grant,关键字为revoke

　　六、查看权限

　　select * from user_sys_privs;//查看当前用户所有权限

　　select * from user_tab_privs;//查看所用用户对表的权限

　　七、操作表的用户的表



　　select * from zhangsan.tablename

　　八、权限传递

　　即用户A将权限授予B，B可以将操作的权限再授予C，命令如下：

　　grant alert table on tablename to zhangsan with admin option;

//关键字 with admin option

　　grant alert table on tablename to zhangsan with grant option;

//关键字 with grant option效果和admin类似

　　九、角色

　　角色即权限的集合，可以把一个角色授予给用户

　　create role myrole;//创建角色

　　grant create session to myrole;//将创建session的权限授予myrole

　　grant myrole to zhangsan;//授予zhangsan用户myrole的角色

　　drop role myrole;删除角色

数据库的约束

约束：
        用于确保数据库数据满足特定的商业规则。
        Oracle中的约束包括：
                     not null:
                     unique:
                     primary key: pk
                     foreign key: fk
                     check:

       a.not null : 非空约束：
           如果在列上定义了not null，那么增加数据时，必须为该列提供数据。

       b.unique : 唯一约束：
           当定义唯一约束后，该列的值是不能重复的，但是可以为null。比如：身份证号、产品编号、...

       c.primary key : 主键约束：
           用于唯一的标示表行的数据。当定义了主键约束后，该列不但不能重复，而且不能为null。
           注意：一张表最多只能由一个主键（可以有联合主键），但是可以有多个unique约束。

       d.foreign key : 外键约束：
           用于定义主表和从表之间的关系。外键约束要定义在从表上，主表则必须具有主键约束或者unique约束。
           当定义外键约束后，要求外键列的数据必须在主表的主键列存在或是为null。

       e.check : 检查约束：
           用于强制列数据必须满足条件。
           如：假如在sal列上定义了check约束，并要求sal列值在1000—2000之间，

那么在增加数据时，工资少于1000或者大于2000，就会报check约束错误。

游标

一、涉及内容

　　游标的创建与应用

二、具体操作

 （一）填空题

　　1.PL/SQL 程序块主要包含3个部分：声明部分、（执行部分 ）、异常处理部分。

　　2.自定义异常必须使用（RAISE ）语句引发。

（二）选择题

　　1.下列哪一个不是BOOLEAN变量可能的取值？（D ）

　　　　A.TRUE  B.FALSE  C.NULL D.BLANK

　　2.请查看以下IF语句：

复制代码
Declare
     sal number:=500;
     comm number;
  Begin
     If sal <100 then
        Comm :=0;
     Elsif sal <600 then
        Comm: =sal*0.1;
     Else sal <1000 then
        Comm: =sal*0.15;
     Else
        Comm: =sal*0.2;
     End if;
  End;
复制代码
　　在执行了以上语句之后，变量comm 的结果应是：（B ）

　　A.0  B.50  C.75 D.100

　　3．在以下哪些语句中可以包含WHERE CURRENT OF 子句？（CE）

　　　　A.OPEN   B.FETCH C.DELETE D.SELECT E.UPDATE   F.CURSOR

　　4.在异常和oracle错误之间建立关联时，应该在哪个部分完成？（A）

　　　　A.定义部分   B.执行部分  C.异常处理部分

　　5.只能存在一个值的变量是哪种变量？（B ）

　　　　A.游标   B.标量变量  C.游标变量 D.记录变量



（三）编程题

　　1.编写程序计算并输出1~100的和。

　　方案一：

　　语句：

复制代码
Declare
   v_sum  integer:=0;
begin
   for i in 1..100 loop
      v_sum := v_sum+i;
   end loop;
   dbms_output.put_line(‘1~100的和为：’|| v_sum);
end;
/
复制代码
　　截图：



　　方案二：

　　语句：

复制代码
Declare
   v_sum  integer;
begin
    v_sum := 100*101/2;
    dbms_output.put_line(‘1~100的和为：’|| v_sum);
end;
/
复制代码
　　截图：

oracle异常处理

异常处理概念

异常情况处理(EXCEPTION)是用来处理正常执行过程中未预料的事件,

程序块的异常处理预定义的错误和自定义错误,由于PL/SQL程序块一旦产生异常而没有指出如何处理时,

程序就会自动终止整个程序运行.



有三种类型的异常错误：

    1． 预定义 ( Predefined )错误

  ORACLE预定义的异常情况大约有24个。对这种异常情况的处理，

无需在程序中定义，由ORACLE自动将其引发。

    2． 非预定义 ( Predefined )错误

   即其他标准的ORACLE错误。对这种异常情况的处理，

需要用户在程序中定义，然后由ORACLE自动将其引发。

    3． 用户定义(User_define) 错误

 程序执行过程中，出现编程人员认为的非正常情况。对这种异常情况的处理，

需要用户在程序中定义，然后显式地在程序中将其引发。



异常处理部分一般放在 PL/SQL 程序体的后半部,结构为:





EXCEPTION
   WHEN first_exception THEN  <code to handle first exception >
   WHEN second_exception THEN  <code to handle second exception >
   WHEN OTHERS THEN  <code to handle others exception >
END;


异常处理可以按任意次序排列,但 OTHERS 必须放在最后.



5.1.1 预定义的异常处理


   预定义说明的部分 ORACLE 异常错误

错误号

异常错误信息名称

说明

ORA-0001

Dup_val_on_index

违反了唯一性限制

ORA-0051

Timeout-on-resource

在等待资源时发生超时

ORA-0061

Transaction-backed-out

由于发生死锁事务被撤消

ORA-1001

Invalid-CURSOR

试图使用一个无效的游标

ORA-1012

Not-logged-on

没有连接到ORACLE

ORA-1017

Login-denied

无效的用户名/口令

ORA-1403

No_data_found

SELECT INTO没有找到数据

ORA-1422

Too_many_rows

SELECT INTO 返回多行

ORA-1476

Zero-divide

试图被零除

ORA-1722

Invalid-NUMBER

转换一个数字失败

ORA-6500

Storage-error

内存不够引发的内部错误

ORA-6501

Program-error

内部错误

ORA-6502

Value-error

转换或截断错误

ORA-6504

Rowtype-mismatch

宿主游标变量与 PL/SQL变量有不兼容行类型

ORA-6511

CURSOR-already-OPEN

试图打开一个已处于打开状态的游标

ORA-6530

Access-INTO-null

试图为null 对象的属性赋值

ORA-6531

Collection-is-null

试图将Exists 以外的集合( collection)方法应用于一个null pl/sql 表上或varray上

ORA-6532

Subscript-outside-limit

对嵌套或varray索引得引用超出声明范围以外

ORA-6533

Subscript-beyond-count

对嵌套或varray 索引得引用大于集合中元素的个数.



对这种异常情况的处理，只需在PL/SQL块的异常处理部分，直接引用相应的异常情况名，并对其完成相应的异常错误处理即可。



例1：更新指定员工工资，如工资小于1500，则加100；




复制代码
DECLARE
   v_empno employees.employee_id%TYPE := &empno;
   v_sal   employees.salary%TYPE;
BEGIN
   SELECT salary INTO v_sal FROM employees WHERE employee_id = v_empno;
   IF v_sal<=1500 THEN
        UPDATE employees SET salary = salary + 100 WHERE employee_id=v_empno;
        DBMS_OUTPUT.PUT_LINE('编码为'||v_empno||'员工工资已更新!');
   ELSE
        DBMS_OUTPUT.PUT_LINE('编码为'||v_empno||'员工工资已经超过规定值!');
   END IF;
EXCEPTION
   WHEN NO_DATA_FOUND THEN
      DBMS_OUTPUT.PUT_LINE('数据库中没有编码为'||v_empno||'的员工');
   WHEN TOO_MANY_ROWS THEN
      DBMS_OUTPUT.PUT_LINE('程序运行错误!请使用游标');
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END;
复制代码
 5.1.2 非预定义的异常处理


对于这类异常情况的处理，首先必须对非定义的ORACLE错误进行定义。步骤如下：

1. 在PL/SQL 块的定义部分定义异常情况：





<异常情况>  EXCEPTION;


2. 将其定义好的异常情况，与标准的ORACLE错误联系起来，使用EXCEPTION_INIT语句：

PRAGMA EXCEPTION_INIT(<异常情况>, <错误代码>);


3. 在PL/SQL 块的异常情况处理部分对异常情况做出相应的处理。





例2：删除指定部门的记录信息，以确保该部门没有员工。





复制代码
INSERT INTO departments VALUES(50, 'FINANCE', 'CHICAGO');

DECLARE
   v_deptno departments.department_id%TYPE := &deptno;
   deptno_remaining EXCEPTION;
   PRAGMA EXCEPTION_INIT(deptno_remaining, -2292);
   /* -2292 是违反一致性约束的错误代码 */
BEGIN
   DELETE FROM departments WHERE department_id = v_deptno;
EXCEPTION
   WHEN deptno_remaining THEN
      DBMS_OUTPUT.PUT_LINE('违反数据完整性约束!');
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END;
复制代码




5.1.3 用户自定义的异常处理

当与一个异常错误相关的错误出现时，就会隐含触发该异常错误。

用户定义的异常错误是通过显式使用 RAISE 语句来触发。当引发一个异常错误时，

控制就转向到 EXCEPTION块异常错误部分，执行错误处理代码。



对于这类异常情况的处理，步骤如下：

1． 在PL/SQL 块的定义部分定义异常情况：





<异常情况>  EXCEPTION;


2． RAISE <异常情况>；





3． 在PL/SQL 块的异常情况处理部分对异常情况做出相应的处理。





例3：更新指定员工工资，增加100；





复制代码
DECLARE
   v_empno employees.employee_id%TYPE :=&empno;
   no_result  EXCEPTION;
BEGIN
   UPDATE employees SET salary = salary+100 WHERE employee_id = v_empno;
   IF SQL%NOTFOUND THEN
      RAISE no_result;
   END IF;
EXCEPTION
   WHEN no_result THEN
      DBMS_OUTPUT.PUT_LINE('你的数据更新语句失败了!');
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END;
复制代码




5.1.4  用户定义的异常处理



调用DBMS_STANDARD(ORACLE提供的包)包所定义的RAISE_APPLICATION_ERROR过程，

可以重新定义异常错误消息，它为应用程序提供了一种与ORACLE交互的方法。



RAISE_APPLICATION_ERROR 的语法如下：



    RAISE_APPLICATION_ERROR(error_number,error_message,[keep_errors] );


    这里的error_number 是从 –20,000 到 –20,999 之间的参数，

    error_message 是相应的提示信息(< 2048 字节)，

  keep_errors 为可选，如果keep_errors =TRUE ,

则新错误将被添加到已经引发的错误列表中。如果keep_errors=FALSE(缺省),

则新错误将替换当前的错误列表。



例4：创建一个函数get_salary, 该函数检索指定部门的工资总和，

其中定义了-20991和-20992号错误，分别处理参数为空和非法部门代码两种错误：



复制代码
CREATE TABLE errlog(
  Errcode NUMBER,
  Errtext CHAR(40));

CREATE OR REPLACE FUNCTION get_salary(p_deptno NUMBER)
RETURN NUMBER
AS
  v_sal NUMBER;
BEGIN
  IF p_deptno IS NULL THEN
    RAISE_APPLICATION_ERROR(-20991, ’部门代码为空’);
  ELSIF p_deptno<0 THEN
    RAISE_APPLICATION_ERROR(-20992, ’无效的部门代码’);
  ELSE
    SELECT SUM(employees.salary) INTO v_sal FROM employees
    WHERE employees.department_id=p_deptno;
    RETURN v_sal;
  END IF;
END;

DECLARE
  V_salary NUMBER(7,2);
  V_sqlcode NUMBER;
  V_sqlerr VARCHAR2(512);
  Null_deptno EXCEPTION;
  Invalid_deptno EXCEPTION;
  PRAGMA EXCEPTION_INIT(null_deptno,-20991);
  PRAGMA EXCEPTION_INIT(invalid_deptno, -20992);
BEGIN
  V_salary :=get_salary(10);
  DBMS_OUTPUT.PUT_LINE('10号部门工资：' || TO_CHAR(V_salary));

  BEGIN
    V_salary :=get_salary(-10);
  EXCEPTION
    WHEN invalid_deptno THEN
      V_sqlcode :=SQLCODE;
      V_sqlerr  :=SQLERRM;
      INSERT INTO errlog(errcode, errtext)
      VALUES(v_sqlcode, v_sqlerr);
      COMMIT;
  END inner1;

  V_salary :=get_salary(20);
  DBMS_OUTPUT.PUT_LINE('部门号为20的工资为：'||TO_CHAR(V_salary));

  BEGIN
    V_salary :=get_salary(NULL);
  END inner2;

  V_salary := get_salary(30);
  DBMS_OUTPUT.PUT_LINE('部门号为30的工资为：'||TO_CHAR(V_salary));

  EXCEPTION
    WHEN null_deptno THEN
      V_sqlcode :=SQLCODE;
      V_sqlerr  :=SQLERRM;
      INSERT INTO errlog(errcode, errtext) VALUES(v_sqlcode, v_sqlerr);
      COMMIT;
    WHEN OTHERS THEN
         DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END outer;
复制代码




例5：定义触发器，使用RAISE_APPLICATION_ERROR阻止没有员工姓名的新员式记录插入：





复制代码
CREATE OR REPLACE TRIGGER tr_insert_emp
BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
  IF :new.first_name IS NULL OR :new.last_name is null THEN
    RAISE_APPLICATION_ERROR(-20000,'Employee must have a name.');
  END IF;
END;
复制代码




5.2 异常错误传播

    由于异常错误可以在声明部分和执行部分以及异常错误部分出现，

因而在不同部分引发的异常错误也不一样。





5.2.1 在执行部分引发异常错误
    当一个异常错误在执行部分引发时，有下列情况：

l 如果当前块对该异常错误设置了处理，则执行它并成功完成该块的执行，

然后控制转给包含块。

l 如果没有对当前块异常错误设置定义处理器，则通过在包含块中引发它来传播异常错误。

然后对该包含块执行步骤1)。





5.2.2 在声明部分引发异常错误
    如果在声明部分引起异常情况，即在声明部分出现错误，那么该错误就能影响到其它的块。

比如在有如下的PL/SQL程序：

复制代码
DECLARE
    name varchar2(12):='EricHu';
    其它语句
BEGIN
    其它语句
EXCEPTION
    WHEN OTHERS THEN
    其它语句
END;
复制代码


     例子中，由于Abc number(3)=’abc’; 出错，尽管在EXCEPTION中说明了

WHEN OTHERS THEN语句，但WHEN OTHERS THEN也不会被执行。 

但是如果在该错误语句块的外部有一个异常错误，则该错误能被抓住，如：





复制代码
BEGIN
    DECLARE
    name varchar2(12):='EricHu';
    其它语句
   BEGIN
    其它语句
   EXCEPTION
    WHEN OTHERS THEN
    其它语句
    END;
EXCEPTION
WHEN OTHERS THEN
    其它语句
END;
复制代码




5.3 异常错误处理编程

    在一般的应用处理中，建议程序人员要用异常处理，因为如果程序中不声明任何异常处理，

则在程序运行出错时，程序就被终止，并且也不提示任何信息。下面是使用系统提供的异常来编程的例子。



5.4  在 PL/SQL 中使用 SQLCODE, SQLERRM异常处理函数

    由于ORACLE 的错信息最大长度是512字节，为了得到完整的错误提示信息，

我们可用 SQLERRM和 SUBSTR 函数一起得到错误提示信息，

方便进行错误，特别是如果WHEN OTHERS异常处理器时更为方便。



SQLCODE  返回遇到的Oracle错误号,

SQLERRM  返回遇到的Oracle错误信息.



如:  SQLCODE=-100   è SQLERRM=’no_data_found ‘

 SQLCODE=0      è SQLERRM=’normal, successfual completion’



例6. 将ORACLE错误代码及其信息存入错误代码表



复制代码
CREATE TABLE errors (errnum NUMBER(4), errmsg VARCHAR2(100));

DECLARE
   err_msg  VARCHAR2(100);
BEGIN
   /*  得到所有 ORACLE 错误信息  */
   FOR err_num IN -100 .. 0 LOOP
      err_msg := SQLERRM(err_num);
      INSERT INTO errors VALUES(err_num, err_msg);
   END LOOP;
END;
DROP TABLE errors;
复制代码


例7. 查询ORACLE错误代码；





复制代码
BEGIN
   INSERT INTO employees(employee_id, first_name,last_name,hire_date,department_id)
   VALUES(2222, 'Eric','Hu', SYSDATE, 20);
   DBMS_OUTPUT.PUT_LINE('插入数据记录成功!');

   INSERT INTO employees(employee_id, first_name,last_name,hire_date,department_id)
   VALUES(2222, '胡','勇', SYSDATE, 20);
   DBMS_OUTPUT.PUT_LINE('插入数据记录成功!');
EXCEPTION
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END;
复制代码




例8. 利用ORACLE错误代码，编写异常错误处理代码；





复制代码
DECLARE
   empno_remaining EXCEPTION;
   PRAGMA EXCEPTION_INIT(empno_remaining, -1);
   /* -1 是违反唯一约束条件的错误代码 */
BEGIN
   INSERT INTO employees(employee_id, first_name,last_name,hire_date,department_id)
   VALUES(3333, 'Eric','Hu', SYSDATE, 20);
   DBMS_OUTPUT.PUT_LINE('插入数据记录成功!');

   INSERT INTO employees(employee_id, first_name,last_name,hire_date,department_id)
   VALUES(3333, '胡','勇',SYSDATE, 20);
   DBMS_OUTPUT.PUT_LINE('插入数据记录成功!');
EXCEPTION
   WHEN empno_remaining THEN
      DBMS_OUTPUT.PUT_LINE('违反数据完整性约束!');
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END;

java数据类型

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。

short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。

int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

boolean：只有true和false两个取值。

char：16位，存储Unicode码，用单引号赋值。

2.Java中的常量
十六进制整型常量：以十六进制表示时，需以0x或0X开头，如0xff,0X9A。

八进制整型常量：八进制必须以0开头，如0123，034。

长整型：长整型必须以L作结尾，如9L,342L。

浮点数常量：由于小数常量的默认类型是double型，

所以float类型的后面一定要加f(F)。同样带小数的变量默认为double类型。

如：float f;

    f=1.3f;//必须声明f。

字符常量：字符型常量需用两个单引号括起来（注意字符串常量是用两个双引号括起来）

。Java中的字符占两个字节。一些常用的转义字符：

①\r表示接受键盘输入，相当于按下了回车键；

②\n表示换行；

③\t表示制表符，相当于Table键；

④\b表示退格键，相当于Back Space键；

⑤\'表示单引号；

⑥\''表示双引号；

⑦\\表示一个斜杠\。



3. 数据类型之间的转换
1).简单类型数据间的转换,有两种方式:自动转换和强制转换,

通常发生在表达式中或方法的参数传递时。

自动转换

具体地讲,当一个较"小"数据与一个较"大"的数据一起运算时,系统将自动将"小"数据转换成"大"数据,再进行运算。

而在方法调用时,实际参数较"小",而被调用的方法的形式参数数据又较"大"时(若有匹配的,当然会直接调用匹配的方法),

系统也将自动将"小"数据转换成"大"数据,再进行方法的调用,

自然,对于多个同名的重载方法,会转换成最"接近"的"大"数据并进行调用。

这些类型由"小"到"大"分别为 (byte，short，char)--int--long--float—double。

这里我们所说的"大"与"小",并不是指占用字节的多少,而是指表示值的范围的大小。

①下面的语句可以在Java中直接通过：

byte b;int i=b; long l=b; float f=b; double d=b;

②如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c='c'; int i=c;

System.out.println("output:"+i);输出：output:99;

③对于byte,short,char三种类型而言，他们是平级的，

因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99 ; char c=(char)i; System.out.println("output:"+c);输出：output:c;

强制转换

将"大"数据转换为"小"数据时，你可以使用强制类型转换。即你必须采用下面这种语句格式：

 int n=(int)3.14159/2;可以想象，这种转换肯定可能会导致溢出或精度的下降。

2)表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。

①所有的byte,short,char型的值将被提升为int型；

②如果有一个操作数是long型，计算结果是long型；

③如果有一个操作数是float型，计算结果是float型；

④如果有一个操作数是double型，计算结果是double型；

例， byte b; b=3; b=(byte)(b*3);//必须声明byte。

3)包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，

就可以利用包装类的各种方法进行类型转换了。例如：

①当希望把float型转换为double型时：

float f1=100.00f;

Float F1=new Float(f1);

double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

②当希望把double型转换为int型时：

double d1=100.00;

Double D1=new Double(d1);

int i1=D1.intValue();

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。

即：Boolean(boolean value)、Character(char value)、

Integer(int value)、Long(long value)、Float(float value)

、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。

利用这种方法，也可以实现不同数值型变量间的转换，

例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，

而doubleValue()可以得到其对应的双精度实型变量。

4)字符串与其它类型间的转换

其它类型向字符串的转换

①调用类的串转换方法:X.toString();

②自动转换:X+"";

③使用String的方法:String.volueOf(X);

字符串作为值,向其它类型的转换

①先转换成相应的封装器实例,再调用对应的方法转换成其它类型

例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。

也可以用:Double.valueOf("32.1").doubleValue()

②静态parseXXX方法

String s = "1";

byte b = Byte.parseByte( s );

short t = Short.parseShort( s );

int i = Integer.parseInt( s );

long l = Long.parseLong( s );

Float f = Float.parseFloat( s );

Double d = Double.parseDouble( s );

③Character的getNumericValue(char ch)方法

5）Date类与其它数据类型的相互转换

整型和Date类之间并不存在直接的对应关系，

只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，

在作这种转换时，你可以使用Date类构造函数的三种形式：

①Date(int year, int month, int date)：以int型表示年、月、日

②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分

③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒

在长整型和Date类之间有一个很有趣的对应关系，

就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。

对于这种对应关系，Date类也有其相应的构造函数：

Date(long date)。

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、

getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、

getDay()方法，你也可以将其理解为将Date类转换成int。

而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，

与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，

首先在文件开始引入，

import java.text.SimpleDateFormat;

import java.util.*;

java.util.Date date = new java.util.Date();



//如果希望得到YYYYMMDD的格式

SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");

String dateFormat=sy1.format(date);



//如果希望分开得到年，月，日

SimpleDateFormat sy=new SimpleDateFormat("yyyy");

SimpleDateFormat sm=new SimpleDateFormat("MM");

SimpleDateFormat sd=new SimpleDateFormat("dd");

String syear=sy.format(date);

String smon=sm.format(date);

String sday=sd.format(date);

总结：只有boolean不参与数据类型的转换

（1）.自动类型的转换：a.常数在表数范围内是能够自动类型转换的

b.数据范围小的能够自动数据类型大的转换（注意特例）

int到float，long到float，long到double 是不会自动转换的，不然将会丢失精度

c.引用类型能够自动转换为父类的

d.基本类型和它们包装类型是能够互相转换的

（2）.强制类型转换：用圆括号括起来目标类型，置于变量前



4.Java引用类型
Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

JVM的内存空间：（1）. Heap 堆空间：分配对象 new Student（）

（2）. Stack 栈空间：临时变量 Student stu

（3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：Student stu = new Student（）； //new 在内存的堆空间创建对象

stu.study(); //把对象的地址赋给stu引用变量

上例实现步骤：a.JVM加载Student.class 到Code区

     b.new Student()在堆空间分配空间并创建一个Student实例

     c.将此实例的地址赋值给引用s

字符处理

一、概述

Java是以String类型的对象来实现字符串。String是一个类，

当创建一个String对象后，所创建的字符串是不能改变的。在需要使用可修改的字符串时，

Java提供两个选择—StringBuffer和StringBuilder。

注：声明为String引用的变量在任何时候都可以改变，以指向一些其他的String对象。

二、String构造函数



String s1="hello"与String s2=new String("hello")的区别：

String类在内存中管理一个字符串常量池（常量池的一部分），池中所有相同的字符串常量被合并，只占用一个空间。

String s1=”hello”，先看池中有没有hello，没有就创建一个hello字符串对象。即采用此方法创建0或者1个对象。

String s2=new String(“hello”),这里先在池中创建一个hello对象，同s1，

然后new String()时，将hello对象复制到堆heap中，s2指向堆中的hello。

采用此种方法时创建1或2个对象(当池中有hello时，创建一个对象)。

内存图如下：



三、String类的方法函数

String类有很多方法，这里只介绍几种常见的函数：

1、字符串的长度：

int length();

2、字符串转换

每个类都会实现toString方法，因为它是由Obect定义的，

对于大多数的自创建的类来说，通常要重写toString()并提供自己的字符串表达式。

eg:

复制代码
 1 class Box
 2 {
 3     int x;
 4     int y;
 5     Box(int x,int y)
 6     {
 7         this.x=x;
 8         this.y=y;
 9     }
10     public String toString()
11     {
12         return "test_x"+"-----"+x+"\n"+"test_y"+"-----"+y;
13     }
14 }
15 public class Tset
16 {
17     public static void main(String[] args)
18     {
19             Box b=new Box(1,3);
20             System.out.println(b);
21     }
22
23 }
复制代码
显示结果为：



疑问：看了一下println的源码，不知道此处输出结果为何是如此？

复制代码
 1 private void write(String s) {
 2         try {
 3             synchronized (this) {
 4                 ensureOpen();
 5                 textOut.write(s);
 6                 textOut.flushBuffer();
 7                 charOut.flushBuffer();
 8                 if (autoFlush && (s.indexOf('\n') >= 0))
 9                     out.flush();
10             }
11         }
12         catch (InterruptedIOException x) {
13             Thread.currentThread().interrupt();
14         }
15         catch (IOException x) {
16             trouble = true;
17         }
18     }
复制代码
3、字符抽取

charAt():  返回指定索引处的 char 值。

getChars():一次抽取多个字符。

getBytes():将字符存储在字节数组里。
4、字符串比较

equals()和==：equals()方法是比较String对象中的字符，“==”运算符是比较两个对象是否引用同一实例。

eg:

复制代码
 1 public class Test
 2 {
 3     public static void main(String[] args)
 4     {
 5         String s1=new String("hello");//创建2个对象，一个pool和一个堆里面
 6         String s2="hello";//创建1个对象，s2指向pool里面的"hello"对象
 7         String s3="hello";//创建0个对象,指向s2指向pool里面的那个对象
 8         String s4=s2;//创建0个对象,指向s2,s3指向pool里面的那个对象
 9         String s5=new String("hello");//创建1个对象在堆里面，注意，与s1没关系
10
11         System.out.println(s2=="hello");//true
12         System.out.println(s2==s3);//true,因为指向的都是pool里面的那个"hello"
13         System.out.println(s2==s4);//true,同上,那么s3和s4...:)
14         System.out.println(s1==s5);//false,很明显,false
15         System.out.println(s1==s2);//false,指向的对象不一样
16         System.out.println(s1=="hello");//false
17         System.out.println("---------------");
18         s1=s2;
19         System.out.println(s1=="hello");//true
20     }
21 }
复制代码
执行结果：



复制代码
boolean startsWith(String prefix):判断给定的String是否以特定的字符串开始。

boolean startsWith(String prefix,int toffset):判断此字符从指定索引开始的字符串是否以指定的前缀开始。

endsWith()：判断给定的String是否是以特定的字符串结束。

compareTo():用于比较字符串大小，并考虑大小写字母。

compareIgnoreCase():比较字符串大小并忽略大小写字母。
复制代码
5、查找字符串

isdexOf():查找字符或子串第一次出现的位置

lastIndexOf():查找字符或者子串最后出现的位置
6、更改字符串

因为String对象是不能改变的，当需要更改一个字符串时，

就必须将他复制到一个StringBuffered中，后者使用下列方法，在更改后会构造一个新的字符串副本。

复制代码
substring(int startIndex):返回从startIndex开始到调用字符串结束的子串的一个副本

substring(int startIndex,int endIndex)

,指定起点和终点，返回这中间的字符串，不包括终点。

concat():连接两个字符串，与“+”运算符相同。

replace(char originial,char replacement)

:用一个字符在调用字符串中所有出现另一个字符的地方进行替换。

replace(CharSequence originial,CharSequence replacement)

:用一个字符串序列替换另一个字符串序列。

trim():返回调用字符串对象的一个副本，

但是所有起始和结尾的空白符都被删除了(字符中间的空白符未被删除)。
复制代码
7、改变字符串中字符的大小写

toLowerCase():将所有字符改为小写

toUpperCase():将所有字符改为大写
四：StringBuffer类

StringBuffer是String的一个对等类，提供了字符串的许多功能，可增长、可改写。

这里只介绍几个StringBuffer类的方法函数：

1、append():将任何数据类型的字符串表示连接到调用的StringBuffer对象的末尾。

当定String对象使用“+”运算符时，经常要调用append方法。

StringBuffer s=new StringBuffer("hello");
    System.out.print(s.append(" world"));
2、inser(int index，String str)：将一个字符串插入到另一个字符串中。

3、reverse():颠倒StringBuffer对象中的字符

4、delete(int startIndex,int endIndex),delete(int loc):调用对象中删除一串字符。

五、StringBuilder类

除了一个重要的区别之外，与StringBuffer等同，

这个区别是他不是同步的，意味着他不是线程安全的，其优势是更快的性能，

在使用多线程时必须使用StringBuffer。

方法的重写与重载

方法重载：
Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，

但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同。

调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法

示例代码：



复制代码
public class Test {

    // 无返回值有有int形的参数

    void receive(int i) {
        System.out.println("i=" + i);
    }

    // 无返回值，有float形的参数

    void receive(float f) {
        System.out.println("f=" + f);
    }

    // 无返回值，有String形的参数

    void receive(String s) {
        System.out.println("s=" + s);
    }

    public static void main(String[] args) {
        Test m = new Test();
        m.receive(1234);
        m.receive(56.78f);
        m.receive("方法重载");
    }
}
复制代码


注意：

Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法。


方法重写：
在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，

而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，

而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
示例代码：

复制代码
public class test {
    public static void main(String[] args) {
        new Derived();
    }
}

class Base {
    private int i = 2;

    public Base() {
        display();
    }

    public void display() {
        System.out.println(i);
    }
}

class Derived extends Base {
    private int i = 22;

    public Derived() {
        i = 222;
    }

    public void display() {
        System.out.println(i);
    }
}
复制代码


super关键字：
若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，

则新方法将覆盖原有的方法。 如需父类中原有的方法，可使用super关键字，

该关键字引用了当前类的父类。


总结：
方法重载：
1.必须具有不同的参数列表；
2.可以有不同的返回类型，只要参数不同就可以了。
3.可以有不同的访问修饰符。
方法重写：
1.参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2.返回类型必须相同。
3.访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4.方法重写主要优点是能够定义某个子类独有的特征。这也是多态的体现。

数组

数组？什么是数组？在我印象中的数组是应该这样的：通过new关键字创建并组装他们，

通过使用整形索引值访问它的元素，并且它的尺寸是不可变的！

      但是这只是数组的最表面的东西！深一点？就是这样：

数组是一个简单的复合数据类型，它是一系列有序数据的集合，它当中的每一个数据都具有相同的数据类型，

我们通过数组名加上一个不会越界下标值来唯一确定数组中的元素。

      还有更深的，那就是数组是一个特殊的对象！！（对于这个LZ理解的不是很好，对JVM也没有看，所以见解有限）

。  6 
      不管在其他语言中数组是什么，在java中它就是对象。一个比较特殊的对象。

复制代码
public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        System.out.println("array的父类是：" + array.getClass().getSuperclass());
        System.out.println("array的类名是：" + array.getClass().getName());
    }
}
-------Output:
array的父类是：class java.lang.Object
array的类名是：[I
复制代码
      从上面示例可以看出,数组的是Object的直接子类,它属于“第一类对象”

，但是它又与普通的java对象存在很大的不同，从它的类名就可以看出：[I，这是什么东东？？

在JDK中我就没有找到这个类，话说这个"[I”都不是一个合法标识符。怎么定义成类啊？

所以我认为SUM那帮天才肯定对数组的底层肯定做了特殊的处理。

      我们再看如下示例：

复制代码
public class Test {
    public static void main(String[] args) {
        int[] array_00 = new int[10];
        System.out.println("一维数组：" + array_00.getClass().getName());
        int[][] array_01 = new int[10][10];
        System.out.println("二维数组：" + array_01.getClass().getName());

        int[][][] array_02 = new int[10][10][10];
        System.out.println("三维数组：" + array_02.getClass().getName());
    }
}
-----------------Output:
一维数组：[I
二维数组：[[I
三维数组：[[[I
复制代码
      通过这个实例我们知道：[代表了数组的维度，一个[表示一维，两个[表示二维。

可以简单的说数组的类名由若干个'['和数组元素类型的内部名称组成。不清楚我们再看：

复制代码
public class Test {
    public static void main(String[] args) {
        System.out.println("Object[]:" + Object[].class);
        System.out.println("Object[][]:" + Object[][].class);
        System.err.println("Object[][][]:" + Object[][][].class);
        System.out.println("Object:" + Object.class);
    }
}
---------Output:
Object[]:class [Ljava.lang.Object;
Object[][]:class [[Ljava.lang.Object;
Object[][][]:class [[[Ljava.lang.Object;
Object:class java.lang.Object
复制代码
      从这个实例我们可以看出数组的“庐山真面目”。同时也可以看出数组和普通的Java类是不同的，

普通的java类是以全限定路径名+类名来作为自己的唯一标示的，

而数组则是以若干个[+L+数组元素类全限定路径+类来最为唯一标示的。

这个不同也许在某种程度上说明了数组也普通java类在实现上存在很大的区别，

也许可以利用这个区别来使得JVM在处理数组和普通java类时作出区分。

     我们暂且不论这个[I是什么东东，是由谁来声明的，怎么声明的）。先看如下：

复制代码
public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        Class clazz = array.getClass();
        System.out.println(clazz.getDeclaredFields().length);
        System.out.println(clazz.getDeclaredMethods().length);
        System.out.println(clazz.getDeclaredConstructors().length);
        System.out.println(clazz.getDeclaredAnnotations().length);
        System.out.println(clazz.getDeclaredClasses().length);
    }
}
----------------Output：
0
0
0
0
0
复制代码
      从这个运行结果可以看出，我们亲爱的[I没有生命任何成员变量、成员方法、

构造函数、Annotation甚至连length成员变量这个都没有，它就是一个彻彻底底的空类。

没有声明length，那么我们array.length时，编译器怎么不会报错呢？

确实，数组的length是一个非常特殊的成员变量。我们知道数组的是Object的直接之类，

但是Object是没有length这个成员变量的，那么length应该是数组的成员变量

，但是从上面的示例中，我们发现数组根本就没有任何成员变量，这两者不是相互矛盾么？

复制代码
public class Main {
    public static void main(String[] args) {
        int a[] = new int[2];
        int i = a.length;
    }
}
复制代码
      打开class文件，得到main方法的字节码：

复制代码
0 iconst_2                   

//将int型常量2压入操作数栈
    1 newarray 10 (int)          

//将2弹出操作数栈，作为长度，创建一个元素类型为int, 维度为1的数组，并将数组的引用压入操作数栈
    3 astore_1                   

//将数组的引用从操作数栈中弹出，保存在索引为1的局部变量(即a)中
    4 aload_1                    

//将索引为1的局部变量(即a)压入操作数栈
    5 arraylength               

 //从操作数栈弹出数组引用(即a)，并获取其长度(JVM负责实现如何获取)，并将长度压入操作数栈
    6 istore_2                  

 //将数组长度从操作数栈弹出，保存在索引为2的局部变量(即i)中
    7 return                   

  //main方法返回
复制代码
      在这个字节码中我们还是没有看到length这个成员变量，

但是看到了这个:arraylength ,这条指令是用来获取数组的长度的，

所以说JVM对数组的长度做了特殊的处理，它是通过arraylength这条指令来实现的。

二、数组的使用方法
      通过上面算是对数组是什么有了一个初步的认识，下面将简单介绍数组的使用方法。

      数组的使用方法无非就是四个步骤：声明数组、分配空间、赋值、处理。

      声明数组：就是告诉计算机数组的类型是什么。有两种形式：int[] array、int array[]。

      分配空间：告诉计算机需要给该数组分配多少连续的空间，记住是连续的。array = new int[10];

      赋值：赋值就是在已经分配的空间里面放入数据。array[0] = 1 、array[1] = 2……

其实分配空间和赋值是一起进行的，也就是完成数组的初始化。有如下三种形式：

int a[] = new int[2];    //默认为0,如果是引用数据类型就为null
        int b[] = new int[] {1,2,3,4,5};
        int c[] = {1,2,3,4,5};
      处理：就是对数组元素进行操作。通过数组名+有效的下标来确认数据。

构造器重载

二、构造器重载：
　　构造器可以认为它是个特殊的方法:无需声明返回值类型,如果声明了返回值类型则变成普通方法;

　　构造器的作用:构造器并不是创建对象,而是初始化实例,严格来说对象是new出来的;

　　构造器重载:完全类似于方法重载 -- 两同(同一个类、方法名相同)-- 一异(形参列表不同)



复制代码
 1 public class Monkey{
 2     private String name;
 3     private double weight;
 4     private int age;
 5
 6     //提供带两个参数的构造器
 7     public Monkey(String name , double weight){
 8         this.name = name;
 9         this.weight = weight;
10     }
11
12     //提供带三个参数的构造器,构造器的作用是用来初始化实例的
13     public Monkey(String name , double weight , int age){
14         this(name,weight);
15         this.age = age;
16     }
17
18     public void info(){
19         System.out.println("这是一只猴子,它的名字是:" + name +
20             ",体重是:" + weight + ",年龄是:" + age);
21     }
22
23     public static void main(String[] args){
24         Monkey m = new Monkey("小金刚",100);
25         m.info();
26         Monkey m2 = new Monkey("金刚",300,20);
27         m2.info();
28     }
29 }
复制代码

多肽

抽象类：主要作用----->封装

　　　　在使用抽象类时需要注意几点：
    1、抽象类不能被实例化（像刚才的动物，实例化是没有任何意义的），

例化的工作应该交由它的子类来完成，它只需要有一个引用即可。

    2、抽象方法必须由子类来进行重写。

    3、如果类中包含抽象方法，该类必须要定义成抽象类，不管是否还包含有其他方法。

    4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。

    5、子类中的抽象方法不能与父类的抽象方法同名。

    6、abstract不能与final并列修饰同一个类。

    7、abstract 不能与private、static、final或native并列修饰同一个方法。





对多肽的理解：

　　  多肽的三个含义：1）子类都能以父类的身份出现
                              2）子类以父类的身份出现，但是做事情时，还是用自己的方式来实现。
                              3）子类以父类的身份出现时，自己特有的属性和行为将不能被使用。
（来自百度百科）

实例：
复制代码
 1 package SecondWeekSixthDay;
 2 //对多肽的学习
 3
 4 //抽象类
 5 abstract class Animal {
 6     abstract void eat();//抽象方法
 7     }
 8
 9 //子类
10 class Cat extends Animal{
11     public void eat(){/*必须继承父类的抽象方法*/
12         System.out.println("猫吃鱼");
13     }
14     public void catchMouse(){/*子类自身独有的方法*/
15         System.out.println("抓老鼠");
16     }
17 }
18
19 class Dog extends Animal{
20     public void eat(){
21         System.out.println("吃骨头");
22     }
23     public void catchMouse(){
24         System.out.println("看家");
25     }
26 }
27
28 class Pig extends Animal{
29     public void eat(){
30         System.out.println("睡觉");
31     }
32      void sleep(){
33         System.out.println("睡觉");
34     }
35 }
36
37
38
39 /*相当于测试类*/
40 public class DuoTaiDemo{/*方法体*/
41     public static void main(String[] args){/*main函数入口*/
42
43         Animal animal=new Cat();/*作用：调用其他类来定义成一个新类*/
44         animal.eat();/*调用这个类的eat方法*/
45         //animal.catchMouse();/*因抽象类没有这个方法，因此无法调用*/
46         //Cat();/*不能使用调用方法。因方法体中不存在Cat方法*/
47
48         Animal animal2=new Dog();
49         animal2.eat();
50
51         Animal animal3=new Pig();
52         animal3.eat();
53     }
54
55
56 }

集合

范型

是范型里面的通配符，extends, super只是提供上下限的信息给编译起， 

通配符有集合的概念在里面，Fanxin< ？ extends Base>, ?

类型可能是Base的任何子类，所以我们不能有赋值操作，因为子类和子类是不同的类型，

只是子类可以替换父类而已，所以可以按父类来读取值， Fanxin<? super A>, ?

类型是A的超类， 所以我们可以将A的任何子类赋值给他，这样是安全的，但是读取的时候，

是无法知道这是什么类型的，但是java类都是Object类的扩展， 

所以可以获取值赋给obj对象， Object obj = fanxin.get(); 

如果要赋值给其他对象那么只有强制类型转换了。

类的加载与反射

当程序主动使用某个类时，如果该类还未被加载到内存中，

则系统会通过加载、连接、初始化三个步骤来对该类进行初始化。

类加载指的是将类的class文件读入内存，并为之创建一个java.lang.Class对象，

即当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象

系统中所有的类实际上也是实例，都是java.lang.Class的实例

类的加载由类加载器完成，类加载通常由JVM提供。JVM提供的类加载器称为系统类加载器。

开发者可以通过继承ClassLoader基类来创建自己的类加载器

记载类的来源：

1、从本地文件系统加载class文件

2、从JAR包加载class文件

3、通过网络加载class文件

4、把一个Java源文件动态编译，并执行加载

Java虚拟机规范允许系统预先加载某些类

反射

反射机制是什么
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射机制能做什么
反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。

多线程

java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口

程对象是可以产生线程的对象。比如在Java平台中Thread对象，Runnable对象。

线程，是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始，

运行run方法体中的那一段相对独立的过程。相比于多进程，多线程的优势有：

    （1）进程之间不能共享数据，线程可以；

    （2）系统创建进程需要为该进程重新分配系统资源，故创建线程代价比较小；

    （3）Java语言内置了多线程功能支持，简化了java多线程编程。

线程同步

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。

类加载

类的加载指的是将类的.class文件中的二进制数据读入到内存中，

将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，

用来封装类在方法区内的数据结构。类的加载的最终产品是位于堆区中的Class对象，

Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。

异常处理

try {
  File file = new File("d:/a.txt");
  if(!file.exists())
    file.createNewFile();
} catch (IOException e) {
  // TODO: handle exception
}

hrows和thow关键字

　　1）throws出现在方法的声明中，表示该方法可能会抛出的异常，

然后交给上层调用它的方法程序处理，允许throws后面跟着多个异常类型；

　　2）一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。

throw只会出现在方法体中，当方法在执行过程中遇到异常情况时，

将异常信息封装为异常对象，然后throw出去。throw关键字的一个非常重要的作用就是 

异常类型的转换（会在后面阐述道）。

　　throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，

执行throw则一定抛出了某种异常对象。两者都是消极处理异常的方式

（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常

，但是不会由方法去处理异常，真正的处理异常由此方法的上层调用处理。

面向对象

　　面向对象（Object Oriented）是一种新兴的程序设计方法，

或者是一种新的程序设计规范(paradigm)，其

基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。

从现实世界中客观存在的事物（即对象）出发来构造软件系统，

并且在系统构造中尽可能运用人类的自然思维方式。

2、对象

　　对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。

一个对象由一组属性和对这组属性进行操作的一组服务组成。

　　类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

　　当不存在对一个对象的引用时，该对象成为一个无用对象。

Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。

当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

3、类

　　类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述

，其内部包括属性和方法两个主要部分。

在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。

　　Java中的类实现包括两个部分：类声明和类体。

　　类声明

1
[public][abstract|final] class className [extends superclassName] 

[implements interfaceNameList]{……}
　　其中，修饰符public,abstract,final 说明了类的属性，

className为类名，superclassName为类的父类的名字，interfaceNameList为类所实现的接口列表。

　　类体

1
2
3
4
5
6
class className{
    [public | protected | private ] [static] 

[final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] 

[final | abstract] [native] [synchronized] returnType methodName(

[paramList]) [throws exceptionList]{
        statements
    }//成员方法
}
　　成员变量限定词的含义：

static: 静态变量（类变量）
final: 常量；transient: 暂时性变量，用于对象存档，用于对象的串行化
volatile: 贡献变量，用于并发线程的共享
　　方法的实现也包括两部分内容：方法声明和方法体。

　　方法声明

　　方法声明中的限定词的含义：

static: 类方法，可通过类名直接调用
abstract: 抽象方法，没有方法体
final: 方法不能被重写
native: 集成其它语言的代码
synchronized: 控制多个并发线程的访问
　　方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型

，也可以是复合数据类型（又称引用数据类型）。
　　对于简单数据类型来说，java实现的是值传递，

方法接收参数的值，但不能改变这些参数的值。如果要改变参数的值，则用引用数据类型

，因为引用数据类型传递给方法的是数据在内存中的地址，方法中对数据的操作可以改变数据的值。

　　方法体

　　方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。

方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名，则类的成员变量被隐藏。
　　为了区别参数和类的成员变量，我们必须使用this。this用在一个方法中引用当前对象，

它的值是调用该方法的对象。返回值须与返回类型一致，或者完全相同，或是其子类。当返回类型是接口时，返回值必须实现该接口。

　　构造方法

构造方法是一个特殊的方法。Java 中的每个类都有构造方法，用来初始化该类的一个对象。
构造方法具有和类名相同的名称，而且不返回任何数据类型。
重载经常用于构造方法。
构造方法只能由new运算符调用
4、面向对象的基本特性

　　封装

　　封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，

只保留有限的接口和方法与外界进行交互。

封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，

从而避免了外界对对象内部属性的破坏。

　　可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

private：类中限定为private的成员，只能被这个类本身访问。

如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，

可以被这个类本身和同一个包中的类所访问。
protected：类中限定为protected的成员，可以被这个类本身、它的子类（

包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
public：类中限定为public的成员，可以被所有的类访问。


　　继承

　　子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
继承实现了代码的复用。
Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
子类不能继承父类中访问权限为private的成员变量和方法。
子类可以重写父类的方法，即命名与父类同名的成员变量。
　　Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

访问父类被隐藏的成员变量，如：super.variable;
调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
调用父类的构造函数，如：super([paramlist]);
　　多态

　　对象的多态性是指在父类中定义的属性或方法被子类继承之后，

可以具有不同的数据类型或表现出不同的行为。

这使得同一个属性或方法在父类及其各个子类中具有不同的语义。例如："几何图形"的"绘图"方法，

"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

　　Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）

和方法重写实现的动态多态性（运行时多态）。

编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
运行时多态：由于子类继承了父类所有的属性（私有的除外），

所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。

一个对象可以通过引用子类的实例来调用子类的方法。
　　重载（Overloading）

方法重载是让类以统一的方式处理不同数据类型的手段。
一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。
　　重写（Overriding）

子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、

返回类型和参数表，我们说该方法被重写 (Overriding)。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
子类函数的访问修饰权限不能低于父类的。


分类: 1. Java

python

数据类型。

准数据类型

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
————————————————
版权声明：本文为CSDN博主「When happiness knock」的原创文章，

遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43883625/article/details/100036892

迭代

给定一个list或者tuple，用for循环来进行遍历访问，称为迭代
判断是否可以迭代

form collections import Iterable
isinstance('ABC',Iterable)
//判断ABC是否可以迭代
1
2
3
给定list

list('a':1,'b':2,'c':3)
//访问key
for key in d:
    print(key)
for value in d.values():
    print(value)
for k,v in d.items():
    print(k,v);
1
2
3
4
5
6
7
8
对于字符串

for ch in 'ABC'
    print(ch)
1
2
对于二维

d=[[1,1],[1,2],[1,3]]
for x,y in d:
    print(x,y)
1
2
3
对于没有下标

//运用enumerate函数将list变为索引函数对
for i,value in enumerate(['A','B','c']):
    print(i,value)