HTTP协议特点 Hyper text transfer protocol
1.基于TCP/IP的高级协议
2.默认端口号是:80
3.基于请求/响应模型的:一次请求对应一次响应
4.无状态的:每次请求之间相互独立,不能交互数据
url-pattern /* /demo/user *.do
@WebServlet({"/dd","/dd2","/dd3"})
/XXX 路径匹配
/XXX/XXX 多层路径,目录结构
*.do 扩展名匹配 优先级低,先找具体的,没有才找这个
HTTP协议的7中请求方式
get post put delete head options trace
HttpServlet->GenericServlet->Servlet
XML解析
DOM:将标记语言文档一次性加载进内存,在内存中形成一颗dom树
操作方便,可以对文档进行CRUD的所有操作 缺点:占内存 文档1M,如果写的不好,会有1000倍,10000左右
SAX:逐行读取,基于事件驱动
优点:不占内存,读完就释放,内存只有一行
确定:只能读取,不能增删改
CDATA区 <![CDATA[内容]]>
约束文档 DTD和Schema
DTD约束:
内部dtd
外部DTD:
本地:
网络:
Jsoup解析xml
默认编码ISO-8859-1
label 元素不会向用户呈现任何特殊效果。不过，它为鼠标用户改进了可用性。如果您在 label 元素内点击文本，就会触发此控件。就是说，当用户选择该标签时，浏览器就会自动将焦点转到和标签相关的表单控件上。
响应式布局:同一套页面可以兼容不同分辨率的设备 1000 0010 1000 0001 1111 1110 32 16 8 dao entitiy service util web getServletContext()取得的是 配置的参数 getServletConfig()取得的是 配置的参数 Servlet多个用户同时访问时,可能存在线程安全问题,解决:尽量不要在Servlet中定义成员变量,即使定义了也不要对其修改值,只进行访问 1 JS自定义对象 1)有参构造 function Person(name,age){} 2)无参构造 function Perons(){} 3)js的模板对象 var person = new Object(); 4)字面量值(json格式) var person = {"key":value1,"key2":value2} DOM编程 通过document对象方法获取标签对象 getElementsById() getElementsByTagName() getElementsByName() getElementsByClassName() 事件编程 三要素 事件源 标签 事件监听器 写一个函数 注册事件监听器 标签属性绑定当前函数 常用事件 单机 onclick 双击 ondblclik 获取焦点 onfocus 失去焦点 onblur选项卡发生变化 onchange 页面载入事件 onload 鼠标 onmouseover onmouseout 正则表达式 X*:x字符出现0次或多次 X?:x字符出现0次或1次 X+:x字符出现1次或多次 [a-zA-Z0-9] 边界匹配符号 ^$ var regx = /^正则语法$/; regx.test(); 原生js的表单验证 DOM编程,事件编程,innerHTML form表单 action:提交后台地址 method:提交方式 get/post onsubmit:表示表单提交是否成功,若果表单中的每一项验证都正确返回true,提交成功 使用onSubmit()阻止表单的提交,校验失败不提交οnsubmit="return checkt()"; window.οnlοad=function(){}或者body里面 οnlοad="fun()" DOM控制元素样式 1:元素的style属性div.style.border="1px solid red"; 2:提前定义好选择器样式,通过元素的Class属性来设置class属性值 " < td > "+id+" < /td> < td > "+name+" < /td> < td > "+gender+" < /td> < td > < a href = "javascript:void(0)" onclick = "delTr(this)" > 删除 < /a> < /tr>"; //满足正则规则:用户名:满足4-14位的数字或字母组成 var reg = /^[a-zA-Z0-9]{4,14}$/ ; //密码:满足6-16位的数字或字母组成 var reg = /^[a-zA-Z0-9]{6,16}$/ ; //正则表达式 var reg = /^[a-zA-Z0-9]+@[a-zA-Z0-9]+(\.[a-zA-Z]{2,3}){1,2}$/ ; href="#"这种形式会整体刷新页面，而href="javascript:void(0)" 则不会。所以如果是空连接的话，还是推荐javascript:void(0)。 Javascripte设置颜色 String.fontcolor("#0f0"); function Person(name,age){ this.name=name; this.age = age; this.speak = function(){ alert("说话功能"); } } BOM Broswer Object Model 浏览器对象 窗口对象 地址栏对象 历史记录对象 显示器对象 22. IDEA开发软件 5. 用户登录的案例 6. 学生管理系统的代码编写 4. 异常处理方式之throws5. Throwable的常用方法 17. 集合练习之斗地主案例 12. 点名器案例 17. serialVersionUID&transient 10. 生产者消费者问题 #F00红色 #0F0绿色 #00F蓝色 http://www.itheima.com/course/javaeetext.html 课程大纲 var 用定义的是局部变量,不用定义的是全局变量 语句以分号;结尾,只有一条语句可以省略,多条会报错 JSON JavaScript Object Notation轻量级的数据交换格式 CSS的行内方式
a) 行内样式
b)内部样式 样代码和html标签混合使用,不利于后期管理
c)外部样式 1:css样式代码和html标签不会混合使用2:便于管理
选择器
1标签选择器
.ch02{} 类选择器2
#id01{} id选择器3
优先级
id选择器>class选择器>标签选择器
5并集选择器 .dd,#id{}
6交集选择器 #div span{} 父元素 子元素 {} 子元素选择器
7通用选择器 *{
color:red;}
div设置属性需要边框颜色boder-width boder-color border-style才会生效
伪类选择器
a:link{text-decoration:none;color:#jkj} a:hover a:active a:visited{}
link visited hover active
构造方法的调用
1.使用new创建对象会自动调用构造方法
Person person=new Person();
2.使用Class类的newInstance方***调用构造方法
Person person=(Person) Class.forName(“com.Person”).newInstance();
3.用反射中的constructor类 的newInstance 调用构造方法
Constructor constructor=Person.class.getConstructor ();
Person person=constructor.newInstance();
2.3均属于反射机制
上面三中创建对象的时候回自动调用构造方法，
但不是所有的创建对象的时候会调用，比如clone方法（对象的复制），
序列化的时候也会创建对象，这是有jvm创建的，所以也不会调用
单例模式
a)多线程访问的安全问题
b)加上volatile关键字保证变量的一致性
c)防止反射调用私有构造方法
d)让单例可以被序列化
还有可能被克隆和虚拟机层面
volatile关键字优化,变量可能被优化读取和存储,暂时从寄存器里面取可能被更新过了,出现不一致的现象直接从变量的地址中读取数据
类加载器原理
1:类的初始化,类什么时候进行初始化
1)创建实例,new一个对象
2)访问类或者接口的静态变量,或者对该静态变量赋值
3)调用类的静态方法
4)反射(Class.forName(“com.Dog”))
5)初始化父类的子类(会首先初始化子类的父类)
6)JVM启动时表明的启动类,main方法
类的加载
指的是将类的.class文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区,在堆区中创建一个这个类java.lang.Class对象,封装类在方法区类的对象
类的加载过程
加载(load):查找并加载类的二进制数据
链接(link):
验证:确保被加载类的正确性
准备:为类的静态变量分配内存,并将其初始化为默认值
解析:把类中的符号引用转换为直接引用
初始化(initialize):为类的静态变量赋予正确的初始值
.var() .cast .sout .if 进行if判断 intelliJ快捷操作
正常是类信息---->对象 反射是:对象获取类信息
获取Class对象的三种方式
1:Dog dog = new Dot(); dog.getClass();
2:类名.class;
3:Class.forName(com.test.Dog);
创建对象
class.newInstance();无参构造获取对象
Constructor[] con = class.getContructor(String.class);在使用con.newInstance(“小明”);
class com.bai.demo.Dog
获取属性
Field[] fields = class.getFields(); public
获取私有属性 Field[] declaredFields = class.getDeclaredFields();
Modifier.toString(declaredFields.getModifiers()) private/pupblic
declaredFields.getType int String
declaredFields.getName name/age
访问私有构造和方法 (去除访问修饰符检查)
constructor.setAccessible(true);
method.setAccessible(true);
dos修改编码
set character_set_results=gbk;
单行单列 用普通运算符< <= > >= <> !=
多行单利 用in
多行多列以中间表作为一张表,起别名
roperties获取流方式
FileInputStream fis = new FileInputStream(“config.properties”);
InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(“com/res/config.properties”);
JdbcUtils.class.getClassLoader().getResourceAsStream(“com/config.properties”);
DataSource ds = new ComboPooledDataSource();
a’ or ‘a’ = ‘a sql注入
<img src = “” alt替代文本 title鼠标悬浮 height wight 百分比和分辨率有关系 像素定义具体款高
选择排序思想
将数组中0索引对应的元素和后面角标对应的元素进行比较,第一次比较完毕,最小值出现在最小索引处,依次循环
冒泡排序思想 :
两两比较,大的往后方法,第一次比较完毕,最大值就出现在最大索引处,依次这样两两比较…
比较的次数:数组长度-1次
DCL
创建用户
create user ‘用户名’@‘主机名’ identified by ‘密码’;
create user ‘lisi’@‘localhost’ identified by ‘123’;
create user ‘zhangsan’@’%’ identified by ‘123’;
删除用户
drop user ‘zhangsan’@’%’;
修改密码
update user set password = password(‘新密码’) where user =‘用户名’
update user set password = password(‘abc’) where user = ‘lisi’;
set password for ‘root’@‘localhost’ = password(‘123’);
事务的四大特征
原子性:是不可分割的最小操作单位,要么同时成功,要么同时失败.
持久性:当事务提交或回滚后,数据库会持久化的保存数据
隔离性:多个事务之间,相互独立
一致性:事务操作前后,数据总量不变
事务的隔离级别:
多个事务操作同一个数据存在问题;
1:脏读:一个事物,读到另一个事务中没有提交的数据
2:不可重复读(虚读):在同一个事务中,俩次读取到的数据不一样
3:幻读:一个事物操作DML数据表中的所有记录,另一个事务添加了一条数据,则第一个事务查询不到自己的修改
不可重复读侧重表达 读-读，幻读则是说 读-写，用写来证实读的是鬼影。
隔离级别:
1read uncommitted 读未提交 产生脏读,不可重复读,幻读
2read committed 读已提交 (oracle) 不可重复读,幻读
3 repeatabe read: 可重复读 (mysql) 幻读
4 serializable 串行化 可解决所有问题
安全越高,效率越低
select @@tx_isolation
set global transaction isolation level 级别字符串
UDP 每个被传输的数据报必须限定在64kb之内
SELECT@@autocommit 1是自动提交事务 0手动提交 set @@autocommit = 0 oracle是手动提交,需要加commit;
on update cascade on delete cascade;
start transaction;
rollback;
commit;
update employee set dep_id = null where dep_id = 1;
set时可以设置=null,判断是用is null
在MySQL中去掉一个表格的主键需要分2中情况：
1、该列（column）不光设置为主键（primary key），还有自增长（auto_increment）；
句式：alter table +表名+ modify id int, drop primary key;
2、如果没有设置为自增长（auto_increment），那么可以直接删除主键（primary key ）;
句式：alter table +表名+drop primary key;
mysql> alter table t2 drop primary key;
ERROR 1075 (42000): Incorrect table definition; there can be only
one auto column and it must be defined as a key故障分析及排除
? 原因分析:
– 有自动增长属性的字段必须作为主键,不允许删除
? 解决办法:
– 去掉字段的自动增长属性,再删除主键
mysql> alter table t2 modify id int(2) not null;
… …
mysql> alter table t2 drop primary key;
数据库的备份和还原
1:命令行 mysqldump -uroot -proot db18 > D://a.sql
还原 :1登录数据库 2创建数据库 3使用数据库 4执行source 文件路径
2:图形化工具 b.sql
数据库设计范式
1:第一范式:每一列都是不可分割的原子数据项
2:第二范式:消除第一范式基础上的部分依赖
3:第三范式:在第二范式基础上,消除传递依赖
几个概念:
1:函数依赖 学号->姓名
2:完全函数依赖 (学号,课程名称)->分数
3:部分函数依赖: (学号,课程名称)->姓名
4;传递函数依赖 学号->系名->系主任
5:码: 一个属性和属性组,被其他所有属性完全依赖,则称为该表的码 (学号,课程名称)
create database stu;
create database if not exists stu;
create database stu default character set gbk;
show databases;
show create database stu;
alter database stu character set utf8;
drop database stu;
select database();
use stu;
show tables;
desc stus;
show create table stus;
create table stus(id int,name varcher(20),birthday date);
create table s1 like stus;
desc s1;
drop table s1;
drop table is exists s1;
alter table s1 add name varchar(20);
alter table s1 modify name varchar(100);
alter table s2 change name nick varchar(20);
alter table s1 drop name;
rename table s1 to s2; 修改表名
alter table s1 rename to s2;
alter table s1 character set utf8;
insert into s1 (id,name,age) values (1,‘ben’,1);
show variables like ‘character%’;
drop tables stu2;
create table stu2 like stu;
insert into stu2 select * from stu1;
insert into stu2 (name,age) select name,age from stu;
update student set age = 26,address=‘北京’ where id = 3;
delete from stu;
delete from stu where name=‘a’;
truncate table stu;
truncate相当于删除表的结构,在创建一张表
select name as 姓名,age as 年龄 from stu;
select address from stu;
select distinct address from stu;
select math+5 from stu;
select *,(math+english) as 总成绩 from stu;
<> 不等于 !=
没有==
< <= >= <> =
between and
in
like ‘张%’ %任意多个字符,_单个字符
is null 查询某一列为null值,不能=null
select * from stu where age <> 20;
select * from stu where age != 20;
and或者&&,与,sql建议使用前者,后者不通用
or ||
not !
select * from stu where age>35 and sex =‘男’;
select * from stu where age > 35 or sex =‘男’;
select * from stu where id in(1,3,5);
select * from stu where id not in (1,3,5);
select sex,avg(math),count(id) from stu where math > 70 group by sex having count(id)>2;
create table stu(id int,name varchar(20) not null);
- 删除列
alter table 表名 drop 列名; - 修改数据：
- 语法：
- update 表名 set 列名1 = 值1, 列名2 = 值2,… [where 条件];
- 语法：
select
字段列表
from
表名列表
where
条件列表
group by
分组字段
having
分组之后的条件
order by
排序
limit
分页限定
select distinct address from stu;
复合主键***或者联联合主键,俩个合起来作为主键
rid和uid不能重复,设置复合主键,同一个用户不能收藏同一个线路俩次
primary key(rid,uid),
foreign key (rid) references tab_route(rid),
foreign key (uid) references tab_user(uid);
delete和truncate
delete不影响增长主键
truncate影响增长主键
– 使用别名 select name as 姓名,age as 年龄 from student; – 表使用别名 select st.name as 姓名,age as 年龄 from student as st
– 创建一个学Th表 st9，包含字段(id,name,address)， 地址默认值是广州
create table st9 ( id int, name varchar(20), address varchar(20) default ‘广州’ )
– 添加一条记录,使用默认地址
insert into st9 values (1, ‘李四’, default);
Mysql中,唯一约束限定的值可以有多个null
删除唯一约束,不可以通过modify phone varchar(11);,需要Alter table str drop index phone;
主键的删除 Alter table stu drop primary key;
alter table st5 drop primary key;
– 添加主键 alter table st5 add primary key(id);
– 指定起始值为 1000
create table st4 ( id int primary key auto_increment, name varchar(20) ) auto_increment = 1000;
创建好以后修改起始值
alter table st4 auto_increment = 2000
外键约束
contraint 外键名称 foreign key (外键列名称) references 主表名称(主表名名称)
constraint emp_dept_fk foreign key (dep_id) references department(id);
删除外键
Alter table employee drop foreign key emp_demp_fk;
创建表外添加外键
Alter table employee add constraint emp_dept_fk foreign key (dep_id) references department(id);
0–65535 0–1023知名网络服务和应用
应用层 表示层 会话层 传输层 网络层 数据链路层 物理层
线程同步
同步代码块
同步方法
lock锁
//ReentrantLock Lock锁 lock.lock() lock.unlock() try{}finally{lock.unlock}
sleep和wait的区别
sleep: 让线程进入休眠状态,让出CPU时间片,不释放对象监视器的所有权(对象锁)
wait: 让线程进入等待状态,让出CPU的时间片,释放对象监视器的所有权(对象锁),等待其他线程通过notify()来唤醒
this.wait() //线程进入等待状态,释放监视器的所有权(对象锁)
this.notify()唤醒等待的线程,随机的等待的其中的一个
customer顾客 consumer消费者
在一个同步方法中调用另一个对象的同步方法可能造成死锁
ntelliJ IDEA psvm->main 创建对象时.var, 提取变量.field
thread.yield()让出本次CPU的执行时间片,只让一次,一般没用
thread.join()//让其他线程先执行到结束或执行指定时间,再执行当前线程
t.interrupt()只是打了个标记,本身不会中断
t.interrupted()测试中断状态,此方法会把中断标记清除
InterruptException会清除异常标记
最后总结，关于这三个方法，interrupt（）是给线程设置中断标志；interrupted（）是检测中断并清除中断状态；
isInterrupted（）只检测中断。还有重要的一点就是interrupted（）作用于当前线程,比如在main中调用th.interrupted,其实判断的是main的interrupt
，interrupt（）和isInterrupted（）
作用于此线程，即代码中调用此方法的实例所代表的线程。
mysql -uroot -proot
mysql -hip -uroot -p密码
mysql --host=ip --user=root --password=密码
管理员身份运行net start mysql
net stop mysql
services.msc打开服务
Paths和Files工具类 jdk1.7 nio
Path path = Paths.get(“D:\io\test\c.txt”);
String text = “\r\n恰似一江春水向东流”;
try {
Files.write(path, text.getBytes(“UTF-8”), StandardOpenOption.APPEND);
System.out.println(“append success”);
byte[] readAllBytes = Files.readAllBytes(path);
System.out.println(new String(readAllBytes));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Properties总结
Arrays 转List
1.使用原生方式，拆分数组，添加到List
List resultList = new ArrayList<>(array.length);
for (String s : array) {
resultList.add(s);
}
2.使用Arrays.asList()
List resultList= new ArrayList<>(Arrays.asList(array));
注意：调用Arrays.asList()时，其返回值类型是ArrayList，但此ArrayList是Array的内部类，调用add()时，
会报错：java.lang.UnsupportedOperationException，并且结果会因为array的某个值的改变而改变，故需要再次构造一个新的ArrayList。
3.使用Collections.addAll()
List resultList = new ArrayList<>(array.length);
Collections.addAll(resultList,array);
4.使用List.of()
此方法为 Java9新增方法，定义在List接口内，并且为静态方法，故可以由类名直接调用。
List resultList = List.of(array);
不同的字符串，hashcode可能相同。
先看例子：
@Test
public void test6(){
System.out.println(“ABCDEa123abc”.hashCode()); // 165374702
System.out.println(“ABCDFB123abc”.hashCode()); // 165374702
}
HashMap存进去取的时候,除了匹配hash值,还会equals比较内容
问题原因：
nextLine()会把nextInt()，next()，nextDouble()，nextFloat()的结束换行符作为字符串读入，进而不需要从键盘输入字符串nextLine便已经转向了下一条语句执行。
解决办法：
在每一个nextInt()，next()，nextDouble()，nextFloat()后都加一个nextLine()语句，将它们的结束换行符过滤。
Collections.emptyList();直接返回一个空的list[],长度为0,不用再判断null
hash&(n-1)相当于hash%16
treeSet.forEach(s -> System.out.println(s));
treeSet.forEach(System.out::println);
HsahMap添加重复元素K不变(不替换),Value替换
.put()替换
.putIfAbsent(3,“vince”);只会添加不存在相同key的值
数据结构
数组 链表 二叉树(红黑树) 哈希表(数组+链表) 栈 队列
Arrays.copyOf()和System.arraycopy()
两者的区别在于，Arrays.copyOf()不仅仅只是拷贝数组中的元素，在拷贝元素时，会创建一个新的数组对象。而System.arrayCopy只拷贝已经存在数组元素。
如果我们看过Arrays.copyOf()的源码就会知道，该方法的底层还是调用了System.arrayCopyOf()方法。
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
如果要转化为String数组，则有以下两种方式：
而把Object[]给cast成 String[]还是很麻烦的,需要用到这个：
String[] stringArray = Arrays.copyOf(objectArray, objectArray.length, String[].class);
方法一、String[] arr = new String[list.size];
.toArray(arr);//此时arr就有了list中的值了
方法二、String[] arr = (String[])list.toArray(new String[0]);
String[] sids = sList.toArray(new String[sList.size()]);
1)remove
2)泛型
3)接口回调
1.HashMap初始值设置
static int indexFor(int h, int length) {
return h & (length-1);
}
HashMap
初始容量=2^n次方 （保证散列的均匀性） 减少碰撞,同一个位置存的均匀
初始容量0.75>=指定容量 （保证不会resize）
取满足上述两条件的初始容量最小的，没必要浪费物理空间。
HashTabel 11 len2+1 0.75
HashMap 16 len2 0.75
ArrayList 10 len+len/2
vector 10 increment>0 len+increment increment=0 len2
HashSet 16 0.75 len*2
Vector addElement() elementAt() elements() hasMoreElements() nextElements()
Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。
Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变。
当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象，
Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。
list.retainAll() A和B取交集,交集的放在A,A发生变化,返回true (A集合是否发生变化)
addAll()
- removeAll() 一个就是true
- containAll() 全部true
- retainsAll() 取交集,放到第一个里面,第二个不变
gc()
运行垃圾回收器,调用Object中的finalize()方法,回收不用的对象
Random r = new Random(seed) seed相同,产生的随机数相同
符串流 StringReader
以一个字符串为数据源,构建一个字符串流
transient声明一个实例变量,存储对象时,不会维持,默认0
ByteArrayInputStream默认大小32 ,基于内存维护一个数组,无需关闭
字节字符转换流
InputStreamReader
OutputStreamWriter
FileWriter文件字符操作流会自带缓存1024,当緩存满了以后写入或手动刷新或者close后写入
字节操作流,默认每次执行写入操作会直接把数据写入文件
字符流的内部实现还是字节流
out.write(byte[],0,len);不写0和len可能会多读,数组的后半部分是上次的
字符流才有编码问题,字节流没有
缓存的目的
解决在写入文件操作时,频繁的操作文件带来的性能降低问题
BufferedOutputStream 默认的缓存大小是8*1024 8kb,每次写入时存储到缓存中的byte数组中
,当数组存满时,会把数组中的数据写入文件,并且缓存下标归零
FileReader字符缓冲流
1)加入字符缓存流,增强读取功能(readline)
2)更高效的读取数据
GBK 2字节 UTF-83字节
algorithm /??lɡ?r?e?m/
int len = -1 表示没有 每次读取的字节长度
\r\n表示回车
File.renameTo 改名或移动位置
ConcurrentModificationException iterator for()
IOException
FileNotFountException
NumberFormatException
ArithemeticException 算术异常
NoSuchElementException iterator.next()
ClassCastException
NullPointerException
ArrayIndexOutOfBoundsException
InputMissmatchException
在使用Arrays.asList()后调用add，remove这些method时出现
* java.lang.UnsupportedOperationException异常。
InterruptedException thread.join()会抛此异常
javac -d HelloWorld.java
clone
assert b==20:“结果不正确”;
run as
run configrations argument --ea
jdk1.7新特性
try(实现了closeable接口的自动关闭流){
}catch(){}
抽象类构造方法 作用:要通过子类做数据初始化
1.2.3 抽象类和接口的区别
成员区别 抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法 接口 常量;抽象方法
关系区别 类与类 继承，单继承 类与接口 实现，单实现，多实现 接口与接口 继承，单继承，多继承
设计理念区别 抽象类 被继承体现的是：”is a”的关系。共性功能 接口 被实现体现的是：”like a”的关系。扩展功能
对修改关闭 对扩展开放
门 开门 关门
共性 抽象类
接口 扩展 警报器 不是所有门都有警报功能
CSDN 排序
OO
Object Oriented
complicated
封装
encapsulation /?n?k?psju?le??n/
继承
inheritance ?n?her?t?ns
多态
polymorphism pɑl?'m?rf?zm
private Chicken[]
构造方法初始化大小
add(object)
delete
update(object)
find(id)
多态优先级
注意：优先级从高到低：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
在Java中静态方法可以被继承，但是不能被覆盖，即不能重写。
如果子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法，
那么该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。
父类引用指向子类对象时，只会调用父类的静态方法。所以，它们的行为也并不具有多态性。
1)synchronized
1)throws throw
1)访问父类属性
1)有参和无参
1)长方形成员变量
1)Animal a = new Dog();
1)默认修饰符
2)数组对象
3)继承的管理
1)反射
有参 无参 super new
子类
父类
重写方法的规则：
1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：
父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,
只能抛出IOException的子类异常，可以抛出非检查异常。
如果父类只有有参构造,子类构造需要加super,否则编译不过
1:包装类有什么用
2:Math类熟悉
javadoc -d doc -author -version ArrayTool.java
什么情况下需要开始类加载过程的第一个阶段:“加载”。虚拟机规范中并没强行约束，
这点可以交给虚拟机的的具体实现自由把握，但是对于初始化阶段虚拟机规范是严格规定了如下几种情况，
如果类未初始化会对类进行初始化。
1)创建类的实例
2)访问类的静态变量(除常量【被final修辞的静态变量】原因:常量一种特殊的变量，
因为编译器把他们当作值(value)而不是域(field)来对待。如果你的代码中用到了常变量(constant variable)，
编译器并不会生成字节码来从对象中载入域的值，而是直接把这个值插入到字节码中。这是一种很有用的优化，
但是如果你需要改变final域的值那么每一块用到那个域的代码都需要重新编译。
3)访问类的静态方法
4)反射如(Class.forName(“my.xyz.Test”))
5)当初始化一个类时，发现其父类还未初始化，则先出发父类的初始化
6)虚拟机启动时，定义了main()方法的那个类先初始化
Student s = new Student();
Student.class加载进内存
声明一个Student类型引用s
在堆内存创建对象,
给对象中属性默认初始化值
属性进行显示初始化
构造方法进栈,对对象中的属性赋值,构造方法弹栈
将对象的地址值赋值给s
10.12.151.102
面向对象*
能不能把这些步骤和功能在进行封装，封装时根据不同的功能， 进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面 向对象的思想。接下来我们看看面向对象到底是什么?
面向对象思想概述以及特点
面向对象是基于面向过程的编程思想
特点：
- 是一种更符合我们思想习惯的思想
- 可以将复杂的事情简单化
- 将我们从执行者变成了指挥者
面向对象开发 就是不断的创建对象，使用对象，指挥对象做事情。
面向对象设计 其实就是在管理和维护对象之间 的关系。
面向对象特征 封装(encapsulation) 继承(inheritance) 多态(polymorphism)
487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
