java 基础学习笔记

Day1

1.       基本数据类型加String类型作为方法参数或者数据传递的时候，传递的是值，不改变原值；

2.       对象数据类型作为参数传递的时候，传递的地址，改变原值；

 

Collection

 

list                                set

 

ArrayList  LinkedList         hashset     treeset

 

Map

treeMap

HashMap

HashTable

 

Vector是线程安全的，和arraylist结构类似

ArrayList 多用于查询

LinkList 插入和修改

区别：本质在于结构的差异

List可变长的核心在于copy

 

Map  散列结构（Hash）

hashMap和treeMap的区别：hashMap的存储结构是无续的。treeMap的存储是有序的二叉树。

ArrayList和Vector    hashMap和 HashTable  的区别：  vector HashTable  是线程同步的，是线程安全的。    

 

set	最大的特点：存储在set中的数据是唯一的，不会重复

 

1.集合之中只能放对象，不能直接放基本数据类型；数组既可以使用基本数据类型，也可以是对象类型。

 

2.Switch没有break  后面的case语句及default会被执行

 

3.==比较的是地址，equal比较的是值；如果是对象，使用==比较两个不同的对象，返回false

 

String s1="abc";       String s2="abc";       System.out.println(s1==s2);   返回true         String s1= new String("abc");       String s2= new String("abc");       System.out.println(s1==s2);   返回false

4.StringBuilder和StringBuffer的区别：

StringBuilder线程不同步的；StringBuffer是线程同步的； String比较值用equal来比较； 频繁的执行增删改操作时用StringBuffer比用String效率高

5.图片，视频，声音只能使用字节流：

1字节8比特；一字符多少个字节？（不一定）

数字或者字母：1个字符是一个字节；

汉字：1个字符是2个字节；

 

Java的三个模块：jse，jme，jee

Jse：桌面程序，基础知识。

Jme：移动设备。

Jee：企业应用。Web方面，java最擅长的方面。

 

 

软件开发步骤：

立项

需求分析

设计（概要设计，详细设计）

coding

Test（单元，压力测试，功能测试）

Run 维护

 

Day2

面向对象：一切事物都是一个对象（对象的抽象就是class）

属性分类：	表现形式	区别
实例属性	ànew 对象的实例或者int a；	所有对象各有独自的存储空间
静态属性	à由static修饰的属性	所有实例公用存储空间

 

静态属性或者方法先创建：调用通过类名调用

 

Final：

1.       修饰方法：不能被子类复写；

2.       修饰属性：表示常量；

3.       修饰类：不可以被继承；

修饰符：

Protected：同类，本包，跨包子类。

Default：同类，同包。非跨包子类

封装：

封装类记得加上公有无参的构造方法。

在struts hibernate中，属性首字母要小写。第二个字母最好不要大写。uStudent是不对的；

 

*继承：

1.       节省代码，可重用代码

2.       功能扩展

Overrideà重写，方法名相同，参数列表相同。返回值相同，范围访问修饰符子类>=父类

Overloadà重载，方法名相同，参数列表不一致。目的：方法名重用；

范围修饰符和返回值可以不一样；

以上两种方式都体现了多态；

Override：

Parent  p = new Child1();

p.addTV();

Parent  p = new Child2();

p.addTV();

左边是父类，右边是子类，new的不同的子类，调用的方法相同。实现的功能不同。

多态：同一个接口，创建不同的实例，调用不同的功能。

 

Parent  p = new Child();

P调用不到子类中独有的方法；只能调用到parent中有的方法。

 

开闭原则：对增加开放，对修改关闭；不修改原来的东西，只增加

接口和抽象类的区别：

	属性	方法	方法实现	实例化	Abstract
接口	Public static final	全部都是抽象方法	全部实现	不可以	可以不加
抽象类 加abstract修饰	没有要求	可以有抽象方法，也可以有普通方法	只实现抽象方法	不可以	抽象方法必须加abstract 修饰

 

接口设计原则：

n     开发系统时，先设计接口，搭建系统骨架

n     通过更换接口的实现类来更换系统的实现

n     接口应尽量预测出所有功能，系统开发完成之后将不要修改

n     如果接口非改不可，则可以创建一个新的接口或者扩展这个接口

 

 

 

 

Day3

 

*集合：

Hash(散列)à一种算法，输入不定长，输出定长，输出不重复。

      将任意长度的输入，通过散列算法，变成固定长度的输出，这种算法就叫做hash算法。如MD5加密算法。

HashMap通过key-value的方式存取数据。经过特定的hash算法，将key值转换成内存地址，再将value存放到key值转换成内存地址中。在查找的时候，HashMap通过key值查找，首先要将key经过hash算法转换成内存地址，在通过内存地址取出value的值。

 

Map的遍历先将Map转换为set，再遍历set

HashMap map = new HashMap(); Set set1 = map.entrySet();

求-2到2的随机数

System.out.println(2-Math.random()*4+"  ");

 

Day4

异常：

Throw:不该处理的异常应该抛出去。

 

输入输出：

    文件输入输出，缓冲流，对象流

随机访问流：断点续传，多线程下载用RandomAccessFile

序列化：实现serializable接口。使对象可以以流的方式传输

单例模式：singleton

       在整个应用中，只存在一个实例

1.       构造方法私有化，不能随便的被new实例

2.       提供一公共静态方法，返回实例

3.       加同步关键字：synchronized

Private static MySingle instance = null; public MySingle(){ } Public synchronized static MySingle getInstance(){ if(instance == null){        instance = new MySingle(); } return instance; }

数据库文件的读取。

publicclass DBUtil extends Properties{    privatestatic DBUtil instance = null;    private DBUtil(){    } public synchronizedstatic DBUtil getInstanse() {       if(instance == null){         instance = new DBUtil();         try {            instance.load(ClassLoader.getSystemResourceAsStream("DB.properties"));         } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();         }       }       returninstance;    } }

 

final 修饰常量的关键字

finally 在try{}catch{}结构中，不管出没出异常，finally语句块中的内容都会被执行。一般用于出现异常后的善后处理。

finalized() 当垃圾回收器确定不存在该对象的更多引用时，回收此垃圾的最后的一个方法。

System.gc(); 通知jvm回收垃圾。但是不是立即回收，调用此方法和没调用效果一样。

对象相同，hashcode相同；hashcode相同，对象不一定相同

hashcode找地址，equal用来找到对应的内存地址中的对象；

相同的内存地址块中可能存放很多歌对象。

 

Day5

进程：cpu为应用程序分配资源的最小单位

线程：一个进程可以有多个线程。Java进程中至少有一个线程(主线程)。

多线程：耗时操作放在后台线程中做。增强客户的体验。例如下载，更新，大资源的加载

运行到阻塞

1.       sleep()   时间到自动唤醒

2.       wait()    通过notify唤醒

3.       I/O操作未完成

Wait notify或者notifyAll

线程的同步

生产者和消费者问题：

生产者生产一个东西，消费者消费一个东西。生产和消费之间需要同步。 例如： package com.wanghui.day5.n1;   publicclass Bread {      private String food = null;      publicsynchronizedvoid getFood() {       if(this.food==null){         try {            System.out.println("custom wait...");            wait();         } catch (InterruptedException e) {            e.printStackTrace();         }       }       System.out.println("消费者消费"+this.food);       this.food = null;       notify();    }      publicsynchronizedvoid setFood(String food) {       if(this.food != null){         try {            System.out.println("producer wait...");            wait();         } catch (InterruptedException e) {            e.printStackTrace();         }       }       this.food = food;       System.out.println("生产者生产"+this.food);       notify();    }       } 在上述例子中。同步的锁是food。 当food不等于空的时候，不可以执行this.food = food;set方法处于等待状态。当food等于空的时候，执行set方法。给food赋值 当food等于空的时候，不可以执行get方法，get方法处于等待状态。当food不等于空的时候，执行get方法。取完后给food赋值null 线程的同步是通过synchronized关键字实现的

 

同步：可以修饰à方法，代码块，对象

       同一时间，多个线程不能同时调用或访问同步的方法，代码块，对象。

死锁的条件：

1.       互斥，多个线程不能同时使用同一个资源

2.       占有等待，某线程需要多个资源才能完成任务，但是只拥有其中的一部分资源。

3.       非剥夺，所有线程优先级相同，不能在别的对象还没有释放资源的情况下抢夺其他线程的资源

4.       循环等待，没有满足资源的线程无限的等待

死锁的例子：

package com.wanghui.day5.deadlock;   publicclass DeadLockDemo1 {    private String str1 = "筷子1", str2 = "筷子2";    Runnable r1 = new Runnable() {       @Override       publicvoid run() {         eat(str1,str2);       }    };    Runnable r2 = new Runnable() {             @Override       publicvoid run() {         // TODO Auto-generated method stub         eat(str2, str1);       }    };    publicvoid eat(String obj1,String obj2){       synchronized(obj1){    System.out.println(Thread.currentThread().getName()+"已经拥有了"+obj1);         synchronized (obj2) {    System.out.println(Thread.currentThread().getName()+"已经拥有了"+obj2+"开始吃饭");         }       }    }    publicstaticvoid main(String[] args) {       DeadLockDemo1 dl = new DeadLockDemo1();             new Thread(dl.r2).start();       new Thread(dl.r1).start();    } }

反射：

Class.forName(DRIVER); 根据一个字符串，查找到字符串所对应的的类。 主要作用：在加载数据库驱动的时候，将字符串加入到参数传递的时候，可以不用改变代码，只改变传入的参数就可以。牺牲时间换来灵活；

 

Day6

数据库：

创建一张部门表，包括字段（部门编号，部门名称，雇员数量），主键为部门编号

drop table t_dept; create table t_dept(        deptNo int(11) primary key,        deptName varchar(50),        empAccount int(5) ); insert into t_dept(deptNo,deptName,empAccount) values(1001,'设计部',10); insert into t_dept(deptNo,deptName,empAccount) values(1002,'开发部',10); insert into t_dept(deptNo,deptName,empAccount) values(1003,'市场部',10); insert into t_dept(deptNo,deptName,empAccount) values(1005 , 产品部 , 10);

创建一张员工表。包括字段（员工编号，员工姓名，员工性别，电话号码，工作岗位，薪资，部门编号）主键为员工编号。

create table t_emp(        empNo int(11) primary key,        empName varchar(50),        empSex varchar(50),        empTel varchar(50),        position varchar(50),        pay float,        deptNo int(11) );

在创建好的表中添加外键约束关系

alter table t_emp add foreign key t_emp(deptNo)  references  t_dept(deptNo);

连表查询

select * from t_emp as e, t_dept as d where e.deptNo=d.deptNo; 列出所有雇员的雇员名称、部门名称和薪金 select e.empName,d.deptName,e.pay from t_emp as e, t_dept as d where e.deptNo=d.deptNo;

排序：

select * from t_dept order by deptName desc; Desc 降序排序;

使用通配符查询：

Select * from t_dept where deptName like “%e%”;   列出所有姓刘的员工 select * from t_emp where empName like "刘%";   列出电话号码中含有8的员工 select * from t_emp where empTel like "%8%";

自连接：

<>不等于 Select * from product p1,product p2 where p1.id <> p2.id and p1.price=p2.price   where p1.id > p2.id and p1.price=p2.price可以去掉重复的记录

内连接：inner join

select e.empName,d.deptName,e.pay from t_emp as e inner join t_dept as d where e.deptNo=d.deptNo;

左连接：左边表的数据全部出现，右边的表没有匹配的数据用null补全

select e.empName,d.deptName,e.pay from t_emp as e left join t_dept as d on e.deptNo=d.deptNo; 列出部门名称和这些部门的雇员,同时列出那些没有雇员的部门 select d.deptName,e.empName from t_dept as d left join t_emp as e  on d.deptNo = e.deptNo;

右连接：右边表的数据全部出现，左边的表没有匹配的数据用null补全

select e.empName,d.deptName,e.pay from t_emp as e right join t_dept as d on e.deptNo=d.deptNo;

 

基本的sql函数：

创建表 create table product(     pid int primary key auto_increment,     pname  varchar(50),     price float,     quantity int(3),     date date,     typeid int(10) );     create table type(     tid int(10) primary key auto_increment,     typename varchar(50) );

 

1.       计算每种产品的总价格：单价*数量

select * , price*quantity from product;

2.       count(*)记录的总数

select count(*) from product;

3.       sum(quantity)求出的是这一列所有数字的总和

select sum(quantity) from product;

4.       求生产日期在2012-1-1之后的产品

      select * from product p where where p.date>’2012-1-1’

5.       between…and…表示在两个数之间，但是前面的要小，后面的大。

6.       字符串拼接：查出的结果是  x元

select *,concat(price*quantity,’元’)  from product p;

7.  weekday(date) 返回日期所对应得星期，从0开始，例如返回0是星期一

9.          select NOW() from product p; 返回现在的时间

10.     group by 通过…分组,按价格分组，得知有几种价格

      Select price from product group by price;

   分组后，不能再显示其他的字段(因为没有意义)，但是可以使用count 或者sum函数，用以统计每个组里面含有多少个元素

Select price，count(*)  from  product  group by  price;

11.     Group by要写在where字句的下面

select price,count(*) from product where price > 2000 group by price;

12.     价格大于2000，按照价格分组后产品总数量大于2的组有哪些？

select price,count(*) from product where price > 2000 group by price having count(*)>2;

Having也是用于做条件的，having用于在分组之后用于做判断的条件，而where是在group by 之前做判断的。

13． Distinct去掉相同的记录

Select *，distinct(typeid) from product

Select distinct(typeid),quantity from product //按照typeid+quantity的组合来去掉相同的记录

14.    在MySQL中，取前十的元素语句是：

Select * from product order by price desc limit 10;

基本查询语句

l       查询海尔洗衣机贵1000元以上的产品 Select * from product p where p.price > ( Select price+1000 From product p2 Where P2.pname=’海尔洗衣机’ ); 上述例子用到了子查询。 l       查询价格是1000 2000 4000 的产品 select * from product p where p.price in (1000,2000,4000); l       查询和洗衣机类型产品价格一样的产品 1.       select * from product p where p.price in ( select price from product where typeid=2 ); 2.       select * from product p1 where exists(        select p2.price        from product p2        where p2.typeid=2 and p2.price = p1.price ); 使用Exists的效率高，大多数情况下都使用它 l       使用左右连接的时候，使用到on，如果还有条件，则在on后面加上where字句 select e.empName,d.deptName,e.pay from t_emp as e left join t_dept as d on e.deptNo=d.deptNo where empName like ‘张%’; l       列出从事同一种工作但属于不同部门的雇员的不同组合 select * from t_emp e1,t_emp e2 where e1.empNo<e2.empNo and e1.position=e2.position and e1.deptNo <> e2.deptNo; l       找出没有选修过“李明”老师讲授课程的所有学生姓名 select s.sname from S,C,SC where S.SNO=SC.SNO AND C.CNO=SC.CNO AND S.SNO not in (select SNO from Score CTEACHER="李明") l       查询尚未指定班级的学生 select *  from stu where clsid is null l       所有学生的平均年龄 select avg(age) from stu l       学生人数总和 select count(*) from stu l       年龄最大的学生 select *,max(age) from stu l       男女学生分别有多少人 select sex,count(*)  from stu group by sex l       查询年龄大于20的男女学生分别有多少人 select sex,count(*)  from stu where age>20 group by sex l       什么性别的总人数<20个 select sex,count(*)  from stu group by sex having count(*)<20 l       年龄比平均年龄小的学生 select * from stu where age<(select avg(age) from stu) l       查询和“李四”同性别的所有学生 select * from stu where sex=(select sex from stu where sname="李四") l       年龄最大的前3个学生 select * from stu order by age desc limit 3 l       左连接右连接查询结果 全外连接 select * from stu s  full join cls c on s.clsid=c.clsid l       找出没有选修过“李明”老师讲授课程的所有学生姓名--- not in 不范围之内 select * from student s1 where s1.name not in (select s.name from student s,course c,score sc where s.sid = sc.sid and c.cid = sc.cid and c.teacher="李明") l       列出有二门以上（含两门）不及格课程的学生姓名及其平均成绩 SELECT stu.name,AVG(sr.score) FROM student stu,score sr WHERE stu.sid = sr.sid  AND stu.name IN  ( SELECT s.name FROM student s,course c,score sc WHERE s.sid = sc.sid AND c.cid = sc.cid AND sc.score<60 GROUP BY s.name HAVING COUNT(*)>1 ) GROUP BY stu.name l       列出既学过“1”号课程，又学过“2”号课程的所有学生姓名 -- 把部分查询的结果当做表 SELECT t1.s1name FROM (SELECT s1.name s1name,sc1.cid FROM student s1,score sc1 WHERE s1.sid = sc1.sid AND sc1.cid=1) t1, (SELECT s2.name s2name,sc2.cid FROM student s2,score sc2 WHERE s2.sid = sc2.sid AND sc2.cid=2) t2 WHERE t1.s1name=t2.s2name   l       列出“1”号课成绩比“2”号课成绩高的所有学生的学号 SELECT * FROM (SELECT s1.name s1name,sc1.score s1score,sc1.cid FROM student s1,score sc1 WHERE s1.sid = sc1.sid AND sc1.cid = 1)  t1, (SELECT s2.name s2name,sc2.score s2score,sc2.cid FROM student s2,score sc2 WHERE s2.sid = sc2.sid AND sc2.cid =2)  t2 WHERE t1.s1name=t2.s2name AND t1.s1score > t2.s2score   l       列出“1”号课成绩比“2”号课成绩高的所有学生的学号及其“1”号课和“2”号课的成绩 SELECT * FROM (SELECT s1.name s1name,sc1.score s1score,sc1.cid FROM student s1,score sc1 WHERE s1.sid = sc1.sid AND sc1.cid = 1) t1, (SELECT s2.name s2name,sc2.score s2score,sc2.cid FROM student s2,score sc2 WHERE s2.sid = sc2.sid AND sc2.cid =2) t2 WHERE t1.s1name=t2.s2name AND t1.s1score > t2.s2score   l       查询选修课程名称为'java’的学员学号和姓名 select * from student s ,score sc,course c where s.sid = sc.sid and sc.cid = c.cid and c.name="java" l       查询选修课程编号为’2’的学员姓名和所属单位 select s.name,s.department,sc.cid from student s ,score sc where s.sid= sc.sid and sc.cid = 2 l       查询不选修课程编号为’2’的学员姓名和所属单位 select s.name,s.department,sc.cid from student s ,score sc where s.sid= sc.sid and sc.cid<>2 l       查询选修全部课程的学员姓名和所属单位 select * from (SELECT s.name sname ,COUNT(*) t1count  FROM student s,score sc WHERE s.sid = sc.sid GROUP BY s.name) t1, (SELECT COUNT(*) t2count FROM course c) t2 where t1.t1count = t2.t2count   l       查询选修了课程的学员人数 DISTINCT 去掉重复记录 SELECT distinct(sc.sid) FROM score sc select  count(distinct(sc.sid)) from score sc l       查询选修课程超过2门的学员学号和所属单位 -- 先找出选修课程超过2门的学员学号 SELECT stu.sid,stu.department FROM student stu WHERE stu.sid IN (SELECT sc.sid FROM score sc,student s WHERE sc.sid = s.sid GROUP BY sc.sid HAVING COUNT(*)>2)

 

三范式：

第一范式：à列要确保原子性;

第二范式：à一个表只描述一件事：除了主键之外，其他列依赖于该主键；

第三范式：à不存在传递依赖

设置自动提交：

事务处理特性

1.       原子性，事务处理过程不可分割

2.       一致性，事务执行前后数据库必须处于一致性状态，只有事务完成后才能被使用者看到

3.       隔离性，并发事务之间不能互相干扰，一个事务操作的数据不会被其他事务看到

4.       持久性，事务一旦提交，就是对数据的永久修改

Set autocommit=flase; //设置不自动提交

事务回滚 rollback

事务提交 commit

 

Day7

数据库设计

M:N 关系中，需要加一张表来表示两个实体之间的关系

1:N  关系中，在N端所对应的的实体中使用1端的主键，惟一键作为外键来表示两个实体之间的关系

 

1.

工厂

职工

产品

编号

名称

地址

编号

名称

规格

职工号

姓名

技术等级

生产

聘用

N

N

N

1

聘用期

工资

数量

生产

工厂编号

产品号

数量

2.

车队：车队编号，车队名称

车辆：车号，厂家，出厂日期

司机：司机编号，姓名，电话，聘用期，车队编号（外键）

车队  1       <聘用>        n       司机

                |

             聘用期

 

 

司机  m       <使用>        n       车辆

                |

         使用日期   公里数

 

使用：司机编号，车辆号，使用日期，公里数

 

3

工程：工程号，工程名，费用合计

职工：职工号，姓名，职务编号

职务：职务编号，职务名，小时工资率

工资：职工号，工程号，工时，实发工资

 

 

4．学校考勤系统的设计，不同部门的上下班时间不相同，需要存储每个员工每天的上下班时间，并且能够查询某个时间段的某个员工迟到或早退的记录

部门：部门号，部门名称，上班时间，下班时间     主键(部门号)

员工：员工号，员工姓名，性别，年龄，住址，部门号（外键）   主键(员工号)

签到：员工号，签到时间，离开时间   主键(员工号)  部门号，员工号参照外部表员工表

记录：员工号是否迟到，是否早退，日期   主键(员工号) 员工号参照外部表员工表