Java学习笔记总结

java基础复习

1、抽象类可以有构造器，可以有一个非抽象的父类

2、垃圾回收机制回收的是堆里面的内存，栈里面的数据自动入栈自动出栈

3、引用类型的数据在堆当中，内存中操作的只有栈，new关键字在堆里面分配一块内存

4、 java中是值传递

5、 String是不可变字符，即一旦分配了内存，此内存的值将不会改变，又将String赋值是，会重新分配一块内存，字符串池： StringBuffer

6、在堆中的东西叫对象

Ø 运行时异常：

ArithmeticException 当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。

ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。

ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。如：

Objectx[] = new String[3];

x[0]= new Integer(0);

ClassCastException视图将对象转换为不是实例的子类时，抛出该异常。如：

Objectx = new Integer(0);

System.out.println((String)x);

illegalArgumentException表明向方法传递了一个不合法或不正确的参数

NegativeArraySizeException如果应用程序视图创建大小为负的数组，则抛出该异常

Ø 编译时异常：

NoSuchMethodException无法找到某一特定方法时，抛出该异常

7、 unicode码范围

汉字：[\u4e00,\u9fa5]

数字：[0x30,0x39]

小写字母：[0x61,0x7a]

大写字母：[0x41,0x5a]

8、 final类

final类能够修饰非抽象类、非抽象类成员方法和变量（静态变量、实例变量、局部变量）

final类不能被继承，没有子类

final方法可以被继承，但不能被子类的方法覆盖

final成员变量表示常量，声明成员变量时，必须赋值（要么在声明的时候赋值，要么在构造器中赋值），赋值后不能被改变

publicfinalint E; //final空白,必须在初始化对象的时候赋初值
        public Test3(int x) {
                E= x;
        }

final不能用于修饰构造方法2.5

9、 static只能修饰成员变量，表示所有对象共享这个数据

static能够修饰成员变量和方法，内部类，也可以形成静态static代码块，不能修饰局部变量

被static修饰的成员变量可以直接用类名来调用，语法如下：

类名.静态放大名（）；

类名.静态变量名；

静态方法中不能用this和super关键字，不能直接访问不带static的成员变量和成员方法

因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract

先运行静态代码块，再运行构造器

10、static和final一块表示什么

staticfinal用来修饰成员变量和成员方法，可理解为全局变量（java中没有全局变量的概念）

staticfinal修饰变量，表示一旦给值就不可修改，并且通过类名就可以访问

staticfinal修饰方法，表示不可覆盖，并可通过类名直接访问

staticfinal修饰一些容器类型（ArrayList、HashMap）的变量，不可以改变容器变量本省，但可以修改容器中存放的对象

11、类成员变量分类

被static修饰的变量叫静态变量或者类变量；

没有被static修饰的变量叫实例变量。

12、命令行参数

java主类参数（即命令行参数）

eclipse中java输入命令行参数，在选定的类中，点击右键run as—Runconfigurations—Arguments-Program arguments-Variables-选择string_prompt

13、Integer.valueOf(String)将字符串转换成Integer包装类

14、一个.java文件中可以有很多类。不过注意以下几点：

a、public 权限的类只能有一个（也可以一个都没有，但最多只有1个）

b、这个.java文件的文件名必须是public类的类名（一般的情况下，这里放置main方法是程序的入口。）

c、若这个文件中没有public的类，则文件名随便是一个类的名字即可

d、用javac 编译这个.java文件的时候，它会给每一个类生成一个.class文件

15、面向对象、面向过程

面向对象的三大特性：封装、继承、多态

面向过程：C语言的底层语言的特性

16、类和对象：

一个类中可以有多个对象，类是对对象的描述

一个类中的成员：

字段：封装private

方法：类的行为

构造器：与类同名，没有返回值。作用：初始化成员变量。默认构造器：无参且同名没有返回值，当一个类显示的表明构

造器，则类不自己建立默认构造器

内部类

17、类之间的关系：继承耦合度最高

A．继承（is-a）: 单继承多实现 extends 优点：减少了代码的冗余、缺点：耦合度太高

B．实现:

C．组合(has-a):

合成:个体和整体的关系，个体与整体生命周期相同，公司和部门的关系

聚合：个体和整体的关系，生命周期不同，学生和学校的关系

关联：双向关联

Class Person{

Petpet;}

ClassPet{

Personowner;

}

D．依赖(use-a):一个类作为另一个类方法的参数或者是返回值，称为依赖

18、java设计原则

低耦合高内聚

可扩展性和可维护性

19、继承：

子类中的成员：

1）从父类中继承的可视化（非私有的）的成员（字段、方法），不能继承父类的构造器

2）子类所特有的成员（字段、方法、构造器）

3）重载父类的成员（方法）多态

重载的条件：

a）发生在同一个类或者父子类之间

b）方法名称相同，参数列表（参数的个数，参数的数据类型、参数的顺序）不同

c）返回值无所谓

d）访问权限无所谓

歧义重载：

ma(12,34)//歧义重载，编译错误

publicvoid ma(int i,double j){//打印1}

publicvoid ma(double i,int j){//打印2}

构造器重载：

this：

this.成员（字段、方法）：调用本类的字段、方法

this(参数列表):调用本类的其他构造方法，必须在构造方法的第一句

public Person(int age){

this(age,””);//调用下面那个构造器

}

publicPerson(int age,String name){

this.age= age;//调用本类的字段

this.name= name;

}

super：父类的对象

super.成员：调用父类的成员（方法、字段）

super(参数列表)：调用父类的构造方法，必须位于子类构造方法的第一句

如果父类中没有无参的构造器，在子类中必须显式的调用父类带参数的构造方法（super（参数类表或者this（参数列表）））；如果父类有无参的构造器，则子类中可以不用显式调用父类的构造器，因为系统默认调用super（）;

4）重写父类的成员（方法）多态

重写的条件：

a）发生在父子类之间

b）方法名称相同，参数列表（参数的个数，参数的数据类型、参数的顺序）相同

c）返回值必须相同

d）子类覆盖方法的访问权限大于等于父类被覆盖方法的访问权限

e）子类不能抛出比父类异常更大的异常（RuntimeException例外）

5）隐藏父类的成员（字段）

多态对象：调用隐藏成员，调用的是父类的

调用覆盖成员，调用的是子类的

20、static:类成员

字段：所有对象共享

方法：静态方法不能直接访问非静态的成员，如果需要访问，产生实例访问；

非静态方法能够直接访问静态成员和非静态成员

静态方法中不能有this、super关键字

块：内存中只执行一次，通常用来初始化静态成员

内部类

21、final：终态的

变量：不能第二次赋值，而且必须有初始值

方法：不能被重写

类：不能被继承

22、abstract：

抽象方法必须在抽象类中，抽象类中不一定要有抽象方法

抽象类没有实例

抽象类可以有父类，父类可以是抽象类也可以是非抽象类

抽象类有构造器，不能用来产生本类实例，构造器用来间接产生子类实例时使用

abstract不能与static、final、private一起使用

23、异常处理：

1）try{}catch（）finally{}

2）throws 方法声明后 throws 异常类

3）throw 句子（通常是if）后throw 异常类的实例

4）自定义异常类 extends Exception或者RuntimeException

24、方法重写(override)和重载(overlord)的区别

重写override：子类中出现与父类中签名相同的方法、访问修饰符要等于高于父类、返回值类型，参数列表都相同

重载overlord：一个类内部出现两个及两个以上方法名相同、参数列表不同(参数类型，参数个数，参数类型的顺序)的方法

25、动态多态和静态多态

动态多态（运行时多态）：运行过程中才知道调用那个方法，指的是方法重写

静态多态（编译时多态）：编译时就知道所调用的方法，指的是方法重载

26、如果父类中没有空参构造

那么子类必须同super()的方式显示的调用父类构造

建议：如果父类中出现带参构造，那么必须手动添加空参构造

例：下列代码的运行结果是（ B）

classA{

public A(int a){System.out.println（“A”）;}

}

class B extends A{

publicB(){

super(5);//必须加上这一块，用super（）显示的调用父类中的方法

}

public voidma(){System.out.println(“ma”);}

}

public class test{

public static void main(String[]args){

B b=new B（）;

b.ma();

}

A. 打印输出ma

B. 编译错误

C. 打印输出A

D. 打印输出A ma

27、 static：

表示静态的，修饰的内容属于类成员；被该类的所有对象共享，建议使用类名.的方式访问；修饰的内容在类加载的时候，执行；只能访问被static修饰的内容；修饰的内容只在类加载的时候执行一次。

可以修饰的内容：修饰属性、修饰方法、作为代码块使用 jdbc 加载驱动的时候

static{

Class.forName("");//作为代码块使用

}

特点：

1.修饰的内容属于类成员

2.修饰的方法，不能被重写，可以被重载

3.修饰的内容，执行一次

例：public class HelloWorld{

public staticvoid main(String args[]){

method();

}

public voidmethod(){

try{

System.out.println(“hello我执行”);

}

finally{

System.out.println(“我就不执行”);

}

编译运行后，输出结果是什么？(D )

A.“hello 我执行”

B.“我就不执行”

C.“hello 我执行”

“我就不执行”

D.代码不能编译

因为main方法是用static修饰的静态方法，调用的方法也必须用static修饰，而method();方法没有被static修饰

28、hashcode()返回的是对象的内存地址对应的int类型数据，但是我们可以重写hashCode()方法，返回的就不再是内存地址。

hashcode()相同的对象，这两个对象不一定相同；如果两个对象相同，则hashcode()一定相同。

29、java中的访问修饰符

public：所有

protected：自己、同一包中、子类可以访问

default：默认什么都不加，就是default，自己、同一包中可以访问，但是比protected级别要低即限制更多

friendly：自己、同一包中可以访问

private：自己

例：以下代码的运行结果是：( C )

abstract class abstrctIt {

2. abstractfloat getFloat ();

}
public class AbstractTest extends AbstractIt {

5. privatefloat f1 = 1.0f;

6. privatefloat getFloat () {return f1;}

}

A. 编译成功

B. 第6行产生错误，导致运行失败

C. 第6行产生错误，导致编译失败

D. 第5行产生错误，导致编译失败

默认什么不加的访问修饰符是default，default比private限制少（即更高级），比protected限制多，所有第六行重写方法用的private访问修饰符比父类低级，所有会出现编译失败

30、Math.random()获取[0,1)的值，取不到1；

用法：（int）Math.random()*n+1;取到1到n之间的整数

31、数组、集合、字符串之间的转换

a. Arrays.asList() //将数组转换成集合

例：List list = Arrays.asList(names);//将数组转换成集合。

b.String.valueOf() //将数组转换成字符串、也可将整数转换成字符串

例：char []ch1 = {‘a’,‘c’,‘a’,‘b’,‘a’};

String str2 = String.valueOf(ch1);

例：int num = 123456;

String str =String.valueOf(num);

c.toCharArray()将字符串转换成数组

例：String str = “gdfgdfgd”;

char[] ch = str.toCharArray();

d.Arrays.toString()将字符数组变成字符串特定格式输出，如[1,2,3]

例：String str1 = Arrays.toString(ch);

System.out.println(str1);

e.str.reverse();将字符串反转

例：StringBuffersb =new StringBuffer(“adfsdsd”);

sb.reverse();

32、replace();函数

例1：//将字符串"abcdabcdabdcadcbadcb"的字符出现的次数输出

Stringnum = “abcdabcdabdcadcbadcb”;

String t = num.replace(“a”,"");

System.out.println(num.length()-t.length());

replaceAll()，用正则表达式

例2：//将字符串中的数字去除

String num1 = “ab23c7da45bc5da65bd5c67ad7cb9adcb”;

String t1 = num1.replaceAll("[0-9]", “”);

System.out.println(t1);

例3：//计算字符串的长度，一个字符算两个

byte[]b =str.getBytes();

System.out.println(b.length);//若出现一个汉字代表3个字节的情况，将Utf-8换成GBK就可以了

String m = str.replaceAll("[\u4e00-\u9fa5]", “xx”);

System.out.println(m.length());

33、DecimalFormat（）;将数字转换成特定的格式

例：//数组格式化 int num = 1234567; 换成123，4567

int num = 1234567;

DecimalFormat f =new DecimalFormat("#,####");

String t =f.format(num);

System.out.println(t);

例： //将数组转换成123,4567.89的格式

doubled = 1234567.88898890;

DecimalFormat f =new DecimalFormat("#,####.##");

System.out.println(f.format(d));

34、String类型是否可以被继承，为什么？

不能被继承，因为是被final修饰的类

35、String类型是否是基本类型，比较String类型变量时，== 和equals有何区别？

不是，是引用类型

a.如果 String类型是直接赋值 == 和 equals 效果相同

String a = “abc “;

String b = “abc”;

a ==b 和 a.equals(b)都为true

b.如果String是通过new构建的 == 和equals效果不同

String a = new String（“abc”）；

String b = new String（“abc”）；

a ==b 结果为false

a．equals（b）结果为true

36、char类型中是否可以存放一个汉字，为什么？

可以，char类型中存放的数据以Unicode码存放。

37、Random()函数

//获取1-35之间的随机数

//第一种方法

Random r = new Random();

int n = r.nextInt(35)+1;

//第二种方法Math.random()是取得[0,1)之间的随机小数，取不到1。

int n =(int) (Math.random()*35+1);

java工具类

Object：引用类型的根，是所有类的超类，是java中唯一一个没有父类的类

1、toString():将对象转成字符串

2、equals（）和==的区别：

==：可以判断基本数据类型和引用数据类型

引用数据类型，表示两个对象的引用是否相等，即栈里面引用的地址是否相等

equals：可以判断引用数据类型

引用数据类型：表示两个对象的引用是否相等，但是包装类、String、Date、File除外（这些判断的是对象的值是否相等，即堆内存里面的值是否相等）

Stringstr1 = “abc”；

//创建一个字符串池中的对象，如果里面有此对象了就不再创建了，直接用即可

Stringstr2 = “abc”；

Stringstr3 = new String(“abc”)；

Stringstr4 = new String(“abc”)；

//可能产生两个或一个对象，在堆内存中首先new出一个对象，再复制到字符串池当中，如果字符串池中有此对象，即不复制。所有堆内存中的对象是肯定存在的，字符串池中的对象不一定

System.out.println(str1==str2)；true

System.out.println(str3==str4)；false

//str3在堆内存中new出一个内存、str4在堆内存中重新new出一个内存，在堆内存中相当于等号的右边。在栈内存中，指向堆内存中的引用值不一样，所有为false

System.out.println(str1==str3)；false

//str1是在堆内存中的字符串池里，为“abc”，str3在堆内存new出一个对象‘abc‘占用一块内存，并且复制到字符串池中，如果字符串池中有abc了，即不复制。

System.out.println(str1.equals(str2));true

System.out.println(str3.equals(str4));true

System.out.println(str1.equals(str3));true

//equals在String类型比较的堆内存的值是否相等，str1字符串池中的内存为abc，str3在堆内存中new出的对象是abc，这两个对象虽然分配的内存不同，但是值相等，所以为true

3、重写equals方法必须先重写hashcode方法

相等的对象必须具有相同的哈希码，具有相同哈希码的对象不一定相等

3、clone（）克隆

浅表克隆：复制原对象的所有变量的备份,但是引用类型的变量指向原对象的数据

必须实现一个接口implements Cloneable

重写Object类的克隆方法clone()

深表克隆：复制原对象的所有变量的备份，包括引用类型

4、反射Class.forName(“com.A”);

破坏了底层的封装性

5、包装类

byteByte

shortShort

longLong

floatFloat

doubleDouble

BooleanBoolean

intIntegar

charCharacter

包装类与字符串转换：

xxxValue（）：转换成其他基本类型

包装类-à字符串 toString（）

System.out.println(i.toString());

字符串-à整形 parseXxx（）

int i4 =Integer.parseInt(“123”);

double i5 =Double.parseDouble(“123.456”);

装箱和拆箱：JDK1.5只会自动装箱和拆箱

装箱：基本数据类型转换为引用数据类型

Integer i5 = 10;

拆箱：引用数据类型转换为基本数据类型

Integer i5 = 10;

int i6 = i5;

6、String类

charAt（）方法：一般与for循环一起，遍历字符串

Stringstr = “Hello Java,Hello World”;

for(int i=0;i<str.length();i++){

System.out.println(charAt(i));

}

concat()方法;拼接字符串，将指定字符串连接到此字符串的结尾

str.concat(“s”); //得到Hello Java,Hello Worlds

startWith()方法;测试此字符串是否已指定的前缀开始，boolean

str. startWith(“Hello”); //true

format()方法:将字符串按照某种格式输出

inti=1;intj=2;

System.out.println(String.format("%d+%d=%d",i,j,i+j));//1+2=3

indexOf(String)方法:输出字符串第一次出现的索引，没有的话输出-1

System.out.println(str.indexOf(“Hello”));//0

lastIndexOf()方法:输出字符串最后一次出现的索引

replace(old String, new String)方法:替换字符串

split()方法:分割字符串

substring(int start,int end)方法:截取字符串

toCharArray()方法:变成字符数组

trim()方法:去掉字符串两端的空格，字符串中间的去不掉

toUpperCase()方法:将字符串转化为大写

7、StringBuffer和StringBuilder区别

StringBuffer线程安全的，同步的，效率比较低，JDK1.0之后出现

StringBuilder线程不安全，不同步的，效率比较高，JDK1.5之后出现

8、StringBuffer方法

StringBuffersb = new StringBuffer（“aaa”）;

append 追加字符串

sb.append(“bb”).append(“bb”);

delete 删除

sb.delete(1,2).delete(1,2);

insert 插入

sb.insert(1,”22”).insert(1,false);

setCharAt 修改

sb.setCharAt(1,’Q’);

replace 替换

sb.replace(1,3,”MMM”);

reverse 反转

sb.reverse();

10、Math方法

Math.ceil(2.4);//3取比值大的最小整数

Math.ceil(-2.4);//-2

Math.floor(2.5);//2取比值小的最大整数

Math.round(2.5);//3四舍五入

Math.round(-2.5);//-2

Math.random()//范围是[0,1)

Math.random()*40+60;//取60到99的成绩

Random方法：范围是[0,1)

Randomran = new Random();

for(inti=0;i<10;i++){

intscore = ran.nextInt(41)+60;//从60到100

System.out.println(score);

}

11、Date方法

SimpleDateFormat类：改变时间的格式

SimpleDateFormatsdf = new SimpleDateFormat(“yyyy/MM/dd HH:mm:ss”);

Datedate = new Date();

//将日期格式转换成指定的字符串

Stringtime = sdf.format(date);

System.out.println(time);//现在的时间以yyyy/MM/dd HH:mm:ss格式输出

//将格式化的字符串转换成日期对象

Datedate = sdf.parse(“1995/07/12 03:00:00”);

System.out.println(date);

TimeZone（）设置时区

TimeZonetime=TimeZone.getTimeZone(“America/Los_Angeles”);

Calendar c2=Calendar.getInstance(time,Locale.US);

Date d=c2.getTime();

GregorianCalendar单独获取年、月、日

GregorianCalendar gc =newGregorianCalendar(2017,3,5);

System.out.println(gc.get(Calendar.MONTH));

System.currentTimeMillis();通常用于循环运算的时间

long startTime = System.currentTimeMillis();

for(){}

longendTime = System.currentTimeMillis();

longtime = endTime- startTime//计算出运算的时间

集合：

1、集合和数组的区别：

数组：可以包含基本数据类型或者引用数据类型的对象，数据定长的，访问较快

集合：只能包含引用数据类型的对象，不定长。

2、集合分类：

Set:集无序，不重复，父接口为Collection

add（）;添加元素

addAll（Collection）;添加子集合

contains（）;是否包括元素

containsAll（）;是否包含子集合

isEmpty();Boolean判断集合长度是否为0

remove（）;移除元素

removeAll（）;移除一个子集合

size（）;集合的大小

toArray（）;将集合转换成数据

Set集合的遍历 Iterator 迭代器

Setset = new HashSet();

Iteratorit = set.iterator();

while(it.hasNext()){

Objectobj = it.next();

System.out.println(obj);

}

Set集合的遍历增强for循环

for(Object obj:set){

System.out.println(obj);

}

HashSet和TreeSet的区别：

HashSet：内部对象散列存取，顺序和输入的顺序不同

TreeSet：元素会进行升序排序（元素是可比较的），顺序和输入的顺序也不同

List:列表有序，重复，父接口为Collection

add（）;添加元素

addAll（Collection）;添加子集合

add（key，元素）;插入元素

get（key）;获取元素

indexOf(元素);返回元素的索引值，如果没有则返回-1

remove(key);移除元素

removeAll（）;移除一个子集合

set（key,元素）;修改元素

toArray();转换成数组

List集合的遍历普通for循环

Listlist = new ArrayList();

for(inti;i<list.size();i++){

Object obj = list.get(i);

System.out.println(obj);

}

List集合的遍历增强for循环

for(Object obj:list){

System.out.println(obj);

}

List集合的遍历 Iterator 迭代器

Iterator it = list.iterator();

while(it.hasNext()){

Objectobj = it.next();

System.out.println(obj);

}

ArrayList和LinkedList区别：

ArrayList底层物理存储为线性的（数组的存储方式），查询效率高，删除、添加等操作效率比较低

LinkedList底层物理存储为链表的，查询效率低，删除、添加效率高

ArrayList和Vector区别：

两者底层物理存储为线性的

ArrayList：线程不安全，不同步的，数据不安全，效率比较高

Vector：线程安全的，同步的，数据安全，效率比较低

Map:字典键值对存储 key唯一，value可重复

put(key,values);添加元素

putAll(map);添加集合

remove（key）;移除一对元素

size();集合长度

containkey(key);是否包含某个键

containvalue（value）;是否包含某个值

Map集合的遍历 keySet()

Set set = map.keySet();

Iterator it = set.iterator();

while(it.hasNext){

Object key = it.next();

Object value = map.get(key);

System.out.println(key+”:”+value);

}

Map集合的遍历 entrySet()

Iterator it = map.entrySet().iterator();

while(it.hasNext()){

Map.Entry entry = (Map.Entry)it.next();

System.out.println(entry.getKey()+”:”+entry.getValue());

}

HashMap和Hashtable的区别：

HashMap：键值对允许为null，线程不安全，不同步，效率比较高

Hashtable：键值对不允许为null，线程安全，同步，效率比价低

HashMap和TreeMap的区别：

HashMap：基于哈希，是无序的

TreeMap：基于树型结构的，按照键升序排序

3、Collections类：

Collections.sort():只针对List集合，集合中的元素必须是可比较的，如果为引用类型，则必须实现Comparator、Compareable（常用）接口

Collections.shuffle（list）：打乱顺序

Collections.rotate（list,int i）:根据指定的长度，轮换指定列表中的长度

Collections.reverse(list):反转集合

泛型：数据类型参数化

1、public void arr(T t1,T t2){

Ttemp = t1;

t1= t2;

t2= temp;

}

2、泛型：安全的，避免了数据类型转换的风险

3、泛型约束：entends：如果有多个约束则使用&连接，约束只能有一个类，可以有多个接口

4、通配符？

上届通配符：？ extends A：表示A或者A的子类

下届通配符：？ super A：表示A或者A的父类类型

Listlist = new ArrayList();

List<?extends Object> listobj = list;//成立

Listlistobj = list;//不成立在泛型中和是同级关系

文件

1、构造方法

Filefile1 =new File(“D:\a.txt”);

File file2 =new File(“d:\UI”,“a.txt”);

File file3 = new File(“D:\UI”);

Filefile4 =new File(file3,“a.txt”);

2、mkdirs()创建多层文件夹

File file5 = new File(“D:\UI\aaa”);

if(!file5.exists()){

file5.mkdirs();

}

3、getAbsolutePath()打印文件路径

getPath()打印文件路径

System.out.println(file5.getAbsolutePath());//D:\UI\aaa

4、getName()()获取文件名//aaa

5、getParent()获取文件目录，不包含文件名//D:\UI

6、isHidden()文件是否被隐藏//false

7、isDirectory()判断是否是文件夹//true

8、isFile() 判断是否是文件

9、exists() 判断是否存在

10、newDate(file5.lastModified()) 获取最后一次修改的日期

11、length() 文件的字节数

12、file5.list() 文件名的遍历

String[]str =file5.list();

for(String s :str){

System.out.println(s);

}// 3.doc

5.FEM

e.txt

13、file5.listFiles() 文件的遍历

File[]files = file5.listFiles();

for(File f :files){

if(f.isFile()){

System.out.println(“文件”+f.getName()+"\t"+new Date(f.lastModified()));

}else{

System.out.println(“文件夹”+f.getName());

}

}//文件3.docFri Feb 24 10:33:28 CST2017

文件5.FEM Fri Feb 24 10:33:37 CST 2017

文件e.txt Fri Feb 24 10:33:32 CST 2017

14、File.listRoots(); 盘符的遍历

File[] f1 = File.listRoots();

for(Filef :f1){

System.out.println(f.toString());

}// C:\

D:\

文件IO流

1、字节流

FileInputStream 输入流读文件

BufferedInputStream输入流读文件

FileOutputStream输出流写入文件

BufferedOutputStream输出流写入文件

字符流

FileReader输入流读文件

DataInputStream输入流读文件

FileWriter输出流写入文件

DataOutputStream输出流写入文件

2、FileInputStream 读取英文文件

FileInputStreamfis = new FileInputStream(“D:\UI\bbb.txt”);

intch = 0;

while((ch= fis.read()) != -1){ //read从此输入流中读取一个数据字节，返回值为int

System.out.print((char)ch);

}

fis.close();//此程序不能读中文

3、FileInputStream 读取中文文件

FileInputStreamfis = new FileInputStream(“D:\UI\bbb.txt”);

byte[]bt = new byte[1024]; //将字节读入字节数组

intlen = 0;

while((len= fis.read(bt))!=-1){

System.out.print(newString(bt,0,len));

}

4、FileOutputStream 写入文件

//搭建管道

FileOutputStream fos = new FileOutputStream(“D:\UI\bbb.txt”);

//读写操作

fos.write(98);//相当于b

fos.write(‘a’);

String str = “ssdsdfsf”; //写入字符串

byte[] b = str.getBytes();

fos.write(b);

fos.flush();//强制性的刷新缓冲区

//关闭流

if(fos !=null){

fos.close();

}

5、DataOutputStream 写入boolean、double等类型的文件

FileOutputStream fos = null;

DataOutputStream dos = null;

fos =new FileOutputStream(“D:\UI\bbb.txt”);

dos =new DataOutputStream(fos);

dos.writeBoolean(true);

dos.write(‘a’);

dos.writeDouble(12.34);

for(inti=0;i<10;i++){

doubled = Math.random();

dos.writeDouble(d);

}

dos.flush();

dos.close();

fos.close();

6、DataInputStream读取boolean、double等类型的文件

FileInputStream fis =null;

DataInputStream dis = null;

fis =new FileInputStream(“D:\UI\bbb.txt”);

dis =new DataInputStream(fis);

booleanbool =dis.readBoolean();

System.out.println(bool);// true

for(inti=0;i<10;i++){

doubleb =dis.readDouble();

System.out.println(b+"\t");

}

dis.close();

fis.close();

// -6.414939283240485E-86

4.7384486223731214E285

7.602269187305488E-298

-1.4027415471626017E-278

9.32553721042958E-38

-1.0852988920338364E40

4.6544251087746895E49

1.0777059597027002E40

4.954807472569955E232

4.957881657894938E232

7、序列化和反序列化

序列化：将对象的数据存储到文件 ObjectOutputStream

反序列化：将文件中的数据重新读到对象 ObjectInputStream

例题：在程序中创建一个Student类型的对象，并把对象信息保存到d:\io\student.txt文件中，然后再从文件中把Student对象的信息读出显示在控制台上。

//先建立Student类

publicclassStudentimplementsSerializable {//编写一个可序列化的类 implements Serializable

privateintid;

private String name;

private String birth;

public Student(intid, Stringname, String birth) {

super();

this.id = id;

this.name = name;

this.birth = birth;

}

@Override

public String toString() {

returnid+""+name+" "+birth;

}

//再进行序列化，即将Student对象写入文件，直接抛出异常范例

publicclass SObjectOutputStreamTest throws IOException{

publicstaticvoid main(String[] args) {

Students1 = new Student(1,“we”,“1987-3-4”);

Students2 = new Student(2,“you”,“1988-3-9”);

FileOutputStreamfos = null;

ObjectOutputStreamoos = null;

fos = new FileOutputStream(“D:\io\student.txt”);

oos = new ObjectOutputStream(fos);

oos.writeObject(s1);

oos.writeObject(s2);

oos.close();

fos.close();

}

//进行反序列化，将文件中的语句读出到控制台，用try catch抓住异常范例

publicclass SObjectInputStreamTest {

publicstaticvoid main(String[]args) {

FileInputStream fis = null;

ObjectInputStream ois = null;

try {

fis =new FileInputStream(“D:\io\student.txt”);

ois =new ObjectInputStream(fis);

Student s1 = (Student)ois.readObject();

Student s2 = (Student)ois.readObject();

System.out.println(s1.toString());

System.out.println(s2.toString());

} catch (FileNotFoundException e) {

e.printStackTrace();

}catch (IOException e) {

e.printStackTrace();

}catch (ClassNotFoundException e) {

e.printStackTrace();

}finally{

try {

if(ois!=null){

ois.close();

}

}catch (IOException e) {

e.printStackTrace();

}

try {

if(fis!=null){

fis.close();

}

}catch (IOException e) {

e.printStackTrace();

}

多线程

1、进程：一个应用程序的一次运行，包含多线程

多线程：一个应用程序运行过程中的某些独立的片段

2、进程与线程的区别（优缺点）

进程：进程间切换耗费系统资源，数据安全（独立的代码和数据空间）

线程：线程间切换系统耗费比较小，数据不安全（共享代码和数据空间）

3、编写线程（掌握）

a．继承Thread类

publicclass ThreadTest1 {

publicstaticvoid main(String[] args) {

ThreadDemotd = new ThreadDemo();

td.start();

for(inti=0;i<1000;i++){

System.out.println(“the main is:”+i);

}

publicclass ThreadDemoextends Thread {

@Override

publicvoid run() {

for(inti=0;i<1000;i++){

System.out.println(“the run is:”+i);

}

b．实现Runnable接口（推荐，因为java类和类是单继承的）

publicclass RunnableTest {

publicstaticvoid main(String[] args) {

RunnableDemord = new RunnableDemo();

Threadthread = new Thread(rd);

thread.start();

for(inti=0;i<1000;i++){

System.out.println(“the main is:”+i);

Thread.sleep(500);

}

publicclass RunnableDemoimplementsRunnable{

@Override

publicvoid run() {

for(inti=0;i<1000;i++){

System.out.println(“the run is:”+i);

Thread.sleep(500);

}

4、CPU调度

抢占式

轮时间片

5、让线程从运行状态进入到阻塞状态

Thread.yield();//暂停

Thread.sleep(500);//休眠

join();//在A线程中加入B线程，待B线程运行完后，再运行A线程

6、线程其他方法

setName（）：给线程起名字，默认的名字Thread-X；x从0开始

getName（）：得到线程的名字

Thread.currentThread().getName()：得到当前运行线程的名字

setPriority();设置线程的优先级数值

getPriority();获得线程的优先级数值

setDaemon(true);设置为守护线程

7、用户线程和守护线程的区别

用户线程（前台线程）：必须执行完毕

守护线程（精灵线程、后台线程）：线程体执行完毕也可，执行不完毕也可以，例如垃圾回收

8、线程同步：

加锁同步：一个对象只能有一把锁

语句加锁 synchronized（对象）{}：可以对本类对象（this）和其他类对象（new 类）加锁；某个方法中的某些句子加锁，无法得知哪些方法是被synchronized保护的

方法加锁 synchronized void methodA（）{}：只能对本类对象加锁；整个方法的所有语句加锁；可以显示得知方法是被synchronized保护的

9、死锁：两个线程，彼此在等待对方占据的锁

锁的几种归还方式：

a．基本上执行完同步的程序代码后，锁会自动归还

b．用break语句跳出同步的语句块，不过这对于写在方法声明的synchronized没有作用

c．遇到return语句

d．遇到了异常

10、线程的生命周期

网络编程（java.net）

1、七层协议：

2、两台电脑之间的通信

ip：ipv4（32位）、ipv6（128位）

端口:1521（oracle）、8080（Tomcat默认的端口）、21（ftp）、80（默认的）

协议：

UDP：传输层，用户数据的协议，无连接的协议，不可靠的，不能够准确到达，效率比较高，适用于数据量比较大并且允许出错的，比如网络视频

TCP/IP:传输层，有连接的协议，可靠的、准确的到达，效率比较低

http：https：ftp等在应用层

http协议：明文无状态的

https：密文

3、客户端和服务器端

基于UDP的

客户端：

Socket client = new Socket(“10.25.116.222”,8088);

服务器端：

ServerSocketserver =ServerSocket(8088);ji

Socket s =server.accept();

4、端口号范围是0-65535，用户普通网络程序用1024以上

5、 InetAddress此类表示互联网协议ip地址

InetAddress address = InetAddress.getByName(“主机名”);

6、getHostName（）获取此IP地址的主机名

getHostAddress（）获取IP地址字符串

getByName()通过主机名获取ip地址

getLocalPort()获取本程序所用接口

JAVA7新特性

1、数值型的数据赋值可以使用下划线_ 增加可读性

不能写在小数点后;

不能在数值型数据的开始

不能在数值型数据的最后添加

Doublepi = 3.1415_9265

Intbillion = 1_000_000_000

2、可以声明n进制数据

Int i1= 0b0100;//4二进制前方放0b

Inti2 = 07; //7八进制前方放0

Inti3 = 0x00ad;//十六进制前方放0x

3、switch:表达式：

jdk1.7以下byte、short、char、int；

jdk1.7以上在上面基础上加上String

4、try（IO流）{

Stringstr=br.readLine();

}catch (ArithmeticException | IOException e) {//catch里可以有多个异常类，不能是父子关系

e.printStackTrace();

}//不用关闭流了，自动资源管理器

5、泛型

Listlist = new List();//jdk1.7以下

Listlist = new List< >(); //jdk1.7以上

6、新加G1垃圾回收器提高效率

7、NIO2

Files.copy(Paths.get(文件一),Paths.get(文件二));//直接复制文件

File.createFile();//创建新文件

File.move();//移动

File.delete();

//用WatchService类型实现文件监控

WatchServicewatchService = FileSystems.getDefault().newWatchService();

JDBC

1、编写jdbc程序的步骤：

1）添加数据库的驱动jar包 ojbc5.jar或者ojdbc6.jar或者classes12.jar

工程名右击—Build Path—Add External Archives—数据库安装路径—jdbc-ojdbc6.jar

2）创建驱动类对象 OracleDriver对象

//创建反射机制

Class.forName(“oracle.jdbc.driver.OracleDriver”);

3）连接数据库 Connection

Stringutl = “jdbc:oracle:thin:@YLMF123-3131857:1521:orcl”;

Stringuser = “scott”;

Stringpassword = “tiger”;

Connectionconn = DriverManager.getConnection(url,user,password);

4）操作数据库

//第一种方法Statement会引起注入，不推荐使用

String sql = “select deptno,dname,loc from dept”;

Statement stmt = conn.createStatement();

ResultSet rs =stmt.executeQuery(sql);//发送sql语句到数据库，然后将查询到的结果返回到ResultSet

//int I = stmt.executeUpdate(sql);//查询影响的行数

while(rs.next()){

intdeptno =rs.getInt(1);//列的索引从1开始计

String dname =rs.getString(2);

String loc =rs.getString(3);

System.out.println(deptno+"\t"+dname+"\t"+loc);

}

//第二种方法PreparedStatement防止注入推荐使用

String sql = “insert into dept(deptno,dname,loc) values(?,?,?)”;

pstmt = conn.prepareStatement(sql);

intdeptno = 35;

String dname = “sdfs”;

String loc = “北京”;

pstmt.setInt(1, deptno);//第一个问号放deptno

pstmt.setString(2, dname);

pstmt.setString(3, loc);

pstmt.executeUpdate();//执行删除、插入、修改语句，executeQuery执行查询语句

5）关闭数据库

rs.close();

stmt.close();

conn.close();

2、批处理：

stmt.addBatch(sql1);

stmt.addBatch(sql2);//可以执行多句sql语句

executeBatch();//执行

String sql=“insert intodept(deptno,dname,loc) values(?,?,?)”;

pstmt=conn.prepareStatement(sql);

pstmt.setInt(1, 51);

pstmt.setString(2, “电信部”);

pstmt.setString(3, “上海”);

pstmt.addBatch();

pstmt.setInt(1, 52);

pstmt.setString(2, “实施部”);

pstmt.setString(3, “广州”);

pstmt.addBatch();

pstmt.executeBatch();

3、事务

conn.setAutoCommit（false）：设置为手动提交事务

conn.commit()：提交

conn.rollback()：回滚,catch里面

4、元数据

DatabaseMetaData：数据库的元数据

DatabaseMetaDatadmd = conn.getMetaData();

dmd.getUserName();//获得数据库名称

dmd.getURL();//获得接口名jdbc:oracle:thin:@YLMF123-2141651:1521:orcl dmd.getDriverName();//当前驱动Oracle JDBC driver

ParameterMetaData：参数的元数据

ResultSetMetaData：结果集的元数据

ResultSetMetaDatarmd = rs.getMetaData();

intcount = rmd.getColumnCount();//获取结果集有多少列

for(int i=0;i<count;i++){

System.out.println(“列标题”+rmd.getColumnLable(i)+”数据类型”+rmd.getColumnTypeName(i));

}

5、DAO:

1)实体类：一个对象相当于数据库表中的一行

privateintdeptno;

public Dept() {}

publicint getDeptno() {

returndeptno;

}

publicvoid setDeptno(intdeptno) {

this.deptno =deptno;

}

@Override

public String toString() {

return"Dept [deptno=" +deptno +",dname=" +dname +", loc=" +loc +"]";

}

2)操作接口：可扩展

publicinterface DeptDao {

void insertDept(Dept dept);

void updateDept(Dept dept);

void deleteDept(intdeptno);

List getAllDepts();

DeptgetDeptByDeptno(intdeptno);

}

3)操作类：

publicclass DeptDaoImplimplementsDeptDao {

@Override

publicvoid insertDept(Dept dept) {

Connection conn = null;

PreparedStatement pstmt = null;

try {

conn = DbUtils.getConnection();

String sql =“insert into dept(deptno,dname,loc)values(?,?,?)”;

pstmt =conn.prepareStatement(sql);

pstmt.setInt(1, dept.getDeptno());

pstmt.setString(2, dept.getDname());

pstmt.setString(3, dept.getLoc());

pstmt.executeUpdate();

} catch (SQLException e) {

e.printStackTrace();

}finally{

DbUtils.closeStatement(pstmt);

DbUtils.closeConnection(conn);

}

4)工具类：将重复的代码包装成工具类

publicclass DbUtils {

privatestaticfinal StringURL =“jdbc:oracle:thin:@YLMF123-2141651:1521:orcl”;

privatestaticfinal StringUSER =“scott”;

privatestaticfinal StringPASSWORD=“tiger”;

private DbUtils(){}//构造方法

static{

try {

Class.forName(“oracle.jdbc.driver.OracleDriver”);

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

publicstatic Connection getConnection(){

Connection conn = null;

try {

conn = DriverManager.getConnection(URL,USER,PASSWORD);

} catch (SQLException e) {

e.printStackTrace();

}

returnconn;

}

publicstaticvoid closeConnection(Connectionconn){

try {

if (conn !=null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

p是英文paragraph段落的缩写，经常被用来创建一个段落，就和你写作文一样。
可以通过删除来删除注释。

Web开发者通常用lorem ipsum text来做占位符，占位符就是占着位置的一些文字，没有实际意义。
为什么叫lorem ipsum text呢?
是因为lorem ipsum是古罗马西塞罗谚语的前两个单词。
从公元16世纪开始lorem ipsum text就被当做占位符了，这种传统延续到了互联网时代。
于此同时，孙悟空也在五指山下压了500年，然后就进化成程序猿了，是不是很巧合，哈哈。

样式的属性多达几千个，但别担心，按照80-20原则，常用的也就几十个，你完全可以掌握它。
当你键入

CatPhotoApp

，你就给h2元素添加了inline style(内联样式)。
内联样式是为元素添加样式的最简单有效的方式，但是更易于维护的方式是使用层叠样式表CSS（Cascading Style Sheets）。
在代码的最顶端，创建一个如下的style元素：

在这个style元素内, 你可以为所有的h2元素创建一个元素选择器。比如，如果你想要将所有的h2元素设置为红色, 你的代码应该看起来像这样：

注意：一定要在属性值的后面加上分号;。

Html

1、属性

align：对齐方式

bgcolor：背景颜色

target:

_blank在新窗口打开 _self默认，在相同的框架打开

_parent在父框架集中打开 _top在整个窗口打开

framename在指定的窗口打开

2、注释

3、文件路径

同一目录下：文件名

上级目录：…/

4、表格

tr行、td列、th表头

<tableborder=“1” align=“center” width="80%"bordercolor=“green” cellspacing=“0” cellpadding=“10pt”><!—cellpadding代表文字和行之间的距离–>

学生成绩表姓名年龄成绩张三李四56

5、表单form

表单域input

type：text文本框、password密码、radio单选按钮、checkbox：复选框

是否需要在本书再版时立即通知您：

<input type="radio"checked=“true”>是

否

submit提交按钮、reset重置按钮、button普通按钮

hidden隐藏域（用来传送数据，不安全）

file：文件上传（两个条件：method=”post”、enctype=”multipart/form-data”）

name：表单域的名字

value：表单域的初始值

size：表单元素的长度，只适用于text、password

maxlength：表单元素中可以输入的最大字符数，只适用于text、password

checked：boolean属性，指定按钮是否是被选中的，只适用于radio、checkbox

readonly：只读的，只适用于text，数据能提交到后台

disabled：表示表单域不能用，数据不能提交到后台

多行文本textarea

//表示可以输入5行20列

下拉列表框select

//可以选中多项

<optionvalue=”beijing”>北京

<optionvalue=”shanghai”>上海

<optionvalue=”qingdao” selected=”true”>青岛//默认选中

域容器fieldset

小标题

用户名：<inputtype=”text”>

密码：<inputtype=”password”>

6、框架frame

frameset：分割窗口

rows分割行cols分割列

frameborder：是否显示框架，0不显示、1显示，默认为1

framespacing：框架间的间距

frame:框架

src：指定框架显示的HTML文件的位置

noresize：设置不可以调整窗口的大小

bordercolor：框架边框的颜色

<framesrc=”header.html” noresize>

<framesetcols=”20%,*”>

<framesrc=”left.html” noresize>

<framesrc=”footer.html” noresize>

浏览器版本较低，请升级后访问

marginwidth：窗口内的内容与窗口左右边缘的距离

marginheigth：窗口内的内容与窗口上下边缘的距离

scrolling：是否显示滚动条，no-不显示、yes-显示、auto-默认自动设置

noframes不支持框架的浏览器

注意：标签与标签不能同时使用，不过，如果添加包含一段文本的

标签，就必须将这一段文字嵌套于标签内

JavaScript

1、增强代码可读性

<-- JavaScript代码 //–>

2、语法结构

1）大小写敏感

2）一句话结束最好加;

3）注释 // /**/

4）弱类型

3、变量命名

1）以字母、下划线_或美元符号$开头

2）余下的字符可以是字母、下划线_或美元符号$、数字

3）最长为255个字符

4）不能有空格、大小写敏感

5）不能使用JavaScript中的关键字或者保留字命名

4、JS变量类型

Undefined：未定义的类型、String、Boolean、Null、Number五种

可以使用typeof（object）来获取变量类型

5、声明 var 变量名[=初始值]

vari = 10;

varj;

alert(typeof(i));//判断i的类型 number

docement.write(123);

6、类型转换

字符串>数值>布尔值低级与高级相加，强制转换成高级的

字符串à数值

parseInt（）、parseFloat（）、Number（）

7、运算符

算术运算符+、-、*、/、%、++、–(前置先自增再运算、后置先运算后自增)

比较运算符 ==、>、>=、<、<=、!=

逻辑运算符 &&、||、!非

赋值运算符 =、+=、-=、*=、/=

8、try{}catch(){}

超级文本标记语言（ HTML（hyper text markup language））超级文本标签语言。
超文本语言包括：文字，图片，音频，视频，动画（cartoon）
Html 是用来描述网页的一种语言，它是一一种超文本标记语言
结构化标准语言（XHTML.XML）
表现标准语言(CSS)
行为标准（DOM.ECMAScript）
html发展史
1 超文本标记语言-在1993年6月互联网工程工作小组工作草案发布（并非标准）。
2.Html2.0-1995年11月作为RFC1866发布，在Rfc 2854于2000年6月发布之后被宣布过时。
3.HTML 3.2 -1996年1月14日。W3c推荐标准。
4.HTML 4.0 -1996年1月14日。W3c推荐标准。
5.HTML 4.01（微小改进） -1999年12月24日。W3c推荐标准。
2000年5月15日发布基本严格的HTML4.01语法。是国际标准化组织和国际电工委员会的标准
6.xhtml1.0-2000年1月26日发布，是w3c推荐标准的，后来经过修订2002年8月1日重新发布
7.Xhtml1.1-2001年5月13日发布
8.Xhtml2.0–w3c的工作草案，由于改动大，学习这项技术的成本过高而最终失败因此，现在最常用的还是xHTML1.0标准
9.Html5-目前最新的版本。于2004年被提出。2007年被w3c接纳并成立新的html工作团队。2008年1月22日公布html5的第一份草案，2012年12月17日html5规范正式定稿，2013年5月6日，HTML5.1正式草案公布
Wordwide web consortium(万维网联盟)
成立于1994年，web技术领域最权威和具影响力
编辑工具
WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。
记事本
Dreamweaver
W3c介绍
W3C标准不是某一个标准，而是一系列的标准集合，一个网页主要由三个部分组成，即结构（structure）,表现（presentation）和行为（behavior）
HTML标题标签

根标签定义语言

字体最大

字号最小
表示强制换行显示，没有结束标签，直接使用
表示标签的开始和结束（单标签） (双标签)

表示一条水平线，注意于
用法一样，没有结束标签字体加粗字体倾斜它是一个带有语气化的标签，它有强调，加强语气的作用。 html中常用的特殊符号及其对应的字符实体特殊符号字符实体实例空格百度&npsp;| href=”#”>goolgle 大于号 > 如果时间>晚上6点，就坐车回家小于号 < 如果时间<早上7点，就走路去上学引号 " W3c规范中，htmld 属性值必须用成对的"引起来版权号(℃) © ©2013-2018北大青鸟

图像标签
p是英文paragraph段落的缩写，经常被用来创建一个段落，就和你写作文一样。
可以通过删除来删除注释。

样式的属性多达几千个，但别担心，按照80-20原则，常用的也就几十个，你完全可以掌握它。
当你键入

CatPhotoApp

在这个style元素内, 你可以为所有的h2元素创建一个元素选择器。比如，如果你想要将所有的h2元素设置为红色, 你的代码应该看起来像这样：

注意：一定要在属性值的后面加上分号;。

http://127.0.0.1:8020/name/2.html?__hbt=1545181143241 本机地址

列表简介
什么是列表，简单来说，列表就是信息资源的一种展示形式，它可以使信息结构化和条理化，并以列表的样式显示出来，以便浏览者能更快捷地获得相应的信息
1：无须列表及其应用
无须列表由标签和

标签组成，使用
- 标签作为无须列表的声明，使用
- 标签作为每个列表项的起始
  2：遵化W3c标准，标签里面只能嵌套
- 标签，不能嵌套其他标签
  3：
- 标签里面可以嵌套任意标签
  无须列表的特性
  1：没有顺序，每个
- 标签独占一行（块元素）
  2：默认
- 标签项前面有个实心小圆点
  3：一般用于无须类型的列表，如导航，侧边栏新闻，有规律的图文组合模块。

有须列表及其应应用
有序列表

标签组成，使用
1. 标签作为有序列表的声明，使用
2. 标签作为每个列表项的起始，与无须列表一样
  有序列表的特性如下
  1：有顺序，每个
3. 标签独占一行
  2：默认
4. 标签项前面有顺序标记
  3：一般用于排序类型的如列表，问卷选项等。
  定义列表及其应用
  标签作为列表的开始
  对于每个列表项的定义则使用
  
  标签来完成
  定义列表的特型如下
  1：没有顺序，每个
  
  标签，
  
  标签独占一行（块元素）
  2：默认没有标记
  3：一般用于(一个标题下有一个或多个列表项)*n的情况
  通常用于带有标题和标题解释性内容的场合
  为什么使用表格，
  
  代表标题，
  
  表示标题解释性内容。
  1：简单通用
  2：结构稳定
  表格的基本结构
  1：单元格
  2：行
  3：列
  创建表格
  1:创建表格标签…
  2:在表格标签…里面建行标签,可以多行
  3：在第一行标签…里创建单元格标签…,用于创建表格表题
  4：在行标签…里创建单元格标签……可以有多个单元格
  表格跨行与跨列
  Border（边界）定义样式

单元格标题表格行单元格 Col(colunmn)列的缩写，span为跨度，所以colspan的意义为跨列跨行使指单元格在垂直方向上的合并 Row为行的意思。Rowspan既跨行视频元素 < video src=”视频路径” controls=”controls”> Src 属性用于指定要播放的视频文件的路径，controls属性用于提供播放器，暂停和音量控件，也可以使用width和height Video的应用 source元素来链接不同的视频文件，浏览器会自动选择第一个可以识别的格式 Autopaly 设置autoplay后，可以使视频文件加载完成自动播放主流浏览器支持的格式浏览器视频格式 IE Fireox OPera Chrome safart Ogg 不支持 3.5+ 10.5+ 5.0+ 不支持 MPEG4 9.0+ 不支持不支持 5.0+ 3.0+ webM 不支持 4.0+ 10.6 6.0+ 不支持音频浏览器音频格式 IE Fireox OPera Chrome safart Ogg 不支持 3.5+ 10.5+ 3.0+ 不支持 MP3 9.0+ 不支持不支持 3.0+ 3.0+ WAV 不支持 4.0+ 10.6+ 不支持 3.0+

单元格内容

音频元素（audio）于视频用法一样
HTML5的结构元素
元素名描述
Header 标记头部区域的内容（用于整个页面或页面中的一块区域）
Footer 标记脚部区域的内容（用于整个页面或页面的一块区域）
Section Web页面中的一块独立区域
Article 独立的文章内容
Aside 相关内容或应用（常用于侧边栏）
nav 导航类辅助内容

>框架
<iframe>框架的主要作用使页面中的部分内容用框架实现，一般用于在页面中引用站外的页面内容，使用比较灵活。例如，在自己制作的网页中引用其他网页
<iframe>语法
 <iframe src="”引用地址”"> 总结无须列表由

标签组成，使用无须列表的内容没有顺序之分，每个列表项独占一行，列表前有实心小圆点有序列表由

标签组成，使用有列表的内容通常显示顺序编写，每个列表项独占一行。定义列表项，和

标签组成，通常用于带有标题和标题解释性内容的场合，

表示标题

表示标题注释性内容使用,,

创建表格。制作跨行跨列的表格跨行：colspan=”横向跨的单元格数” 跨列：rowspan=”纵向跨的单元格数” 网页中的媒体元素包括video视频元素和audio音频元素媒体元素共有的属性：src(链接地址)，controls（控制播放器）可以让媒体元素在不同浏览器下都支持播放的元素（source）语义化结构元素（header section article nav aside footer）的使用。常用的框架技术>内联框架。
配合使用<a>标签的target属性及</a><iframe>标签的name属性，可以实现窗口间的关联。、
<iframe>属性的使用
1: 在被打开的 框架上加name属性， 
<iframe src="“subframe/the_second.html”"/>
2：在超链接上设置target目标窗口属性为希望显示的框架窗口名
<a target="”mainframe”">下边显示第二页</a>


表单
表单就是一个将用户信息组织起来的容器，将需要用户填写的内容放置在表单容器中，当用户单击“提交”按钮的时候，表单会将数据统一发送给服务器。
表单标签及表单属性
使用标签来实现表单的创建，该标签用于在网页中创建表单区域，属于客器标签，其他表单标签需要在它的范围内有效，便是其中的一个，用以设定各种输入资料的方法，标签有两个常用的属性
属性说明
Action 此属性指示服务器上处理表单输出的程序，一般来说，当用户单击表单上的“提交”按钮后，信息发送到web服务器，由action属性指定的程序处理，语法为action=“URl”.如果action属性值为空，则默认表单提交到本页
method 此属性告诉浏览器如何将数据发送给服务器，它指定向服务器发送数据的方法，语法为metho=（get|post）

表格元素及其元素
元素的常用属性
属性说明
type 此属性指定表单元素的类型，可用的类型有text,password,checkbox,radio,submit,rest,file,email,number,url,hidden,url,hidden,image和button。默认为text
name 此属性指定表单元素的名称。例如，如果表单上有几个文本框，可以按名称来标识他们，如username,phone等
value 此属性是可选属性，它指定表单元素的初始值，如果type为radiol类型，则必须指定一个值
size 此属性指定表单元素的初始化。如果type为text或password类型。则表单元素的大小以字符为单位。对于其他输入类型，宽度以像素为单位
maxlenght 此属性用于指定可在tex或password元素中输入的最大字符数。默认值为无限大
checked 此属性用于指定按钮是否被选中的，当输入类型为radio或checkbox时，使用此属性

什么是css
css概念
CSS的概念
Cascading Style Sheet 级联样式表
表现HTML或XHTML文件样式的计算机语言
包括对字体、颜色、边距、高度、宽度、背景图片、网页定位等设定
Css发展史

Css 优势
内容与表现分离
网页的表现统一，容易修改
丰富的样式，使得页面布局更加灵活
减少网页的代码量，增加网页的浏览速度，节省网络带宽
运用独立于页面的CSS，有利于网页被搜索引擎收录

CSS基本语法结构

CSS的最后一条声明后的“;”可写可不写，但是，基于W3C标准规范考虑，建议最后一条声明的结束“;” 都要写上

style标签

行内样式
使用style属性引入CSS样式

内部样式表
CSS代码写在的

优点:方便在同页面中修改样式
缺点:不利于在多页面间共享复用代码及维护，对内容与样式的分离也不够彻底

外部样式表
CSS代码保存在扩展名为.css的样式表中
HTML文件引用扩展名为.css的样式表，有两种方式
1:链接式

2:导入式

链接式与导入式的区别

标签属于XHTML，@import是属于CSS2.1 使用链接的CSS文件先加载到网页当中，再进行编译显示使用@import导入的CSS文件，客户端显示HTML结构，再把CSS文件加载到网页当中 @import是属于CSS2.1特有的，对不兼容CSS2.1的浏览器是无效的行内样式>内部样式表>外部样式表就近原则

CSS3基本选择器
标签选择器
HTML标签作为标签选择器的名称

…

、

类选择器
<标签名 class= “类名称”>标签内容</标签名>
.class { font-size:16px;}

类名称声明
ID选择器
id名称

#id { font-size:16px;}

id选择器
小结
标签选择器直接应用于HTML标签
类选择器可在页面中多次使用
ID选择器在同一个页面中只能使用一次

基本选择器的优先级
ID选择器>类选择器>标签选择器
标签选择器是否也遵循“就近原则”？
不遵循，无论是哪种方式引入CSS样式，一般都遵循ID选择器 > class类选择器 > 标签选择器的优先级

将CSS样式表文件引入到HTML页面
1.直接写在标签元素的属性style中，通常称之为行间样式；
2.将样式写在标签之内，通常称之为内嵌样式表；
3.通过在方式外链CSS样式文件，通常称之为外联样式表；
4.通过@import关键字导入外部CSS样式文件，通常称之为导入样式表。
类选择器
ID选择器：
标签选择器直接用于HTML
类选择器可在页面中多次使用
ID选择器在同一个页面中只能使用一次

Html 课程笔记（1）相关推荐

斯坦福大学李飞飞团队图像分类课程笔记
斯坦福大学李飞飞团队图像分类课程笔记 Stanford image classification course notes 这是斯坦福CS231n课程图像分类基础知识. 目标:这一节先介绍图像分类基本 ...
Udacity机器人软件工程师课程笔记（五）-样本搜索和找回-基于漫游者号模拟器-自主驾驶
9.自主驾驶在接下来的环节中,我们要实现漫游者号的自动驾驶功能. 完成这个功能我们需要四个程序,第一个为感知程序,其对摄像头输入的图片进行变换处理和坐标变换使用.第二个程序为决策程序,功能是帮助漫游 ...
这份深度学习课程笔记获吴恩达点赞
来源:机器之心本文共7470字,建议阅读8分钟. 通过本文用优美的信息图为大家解读深度学习课程的知识与亮点~ 吴恩达在推特上展示了一份由 TessFerrandez 完成的深度学习专项课程信息图,这 ...
Yann Lecun纽约大学《深度学习》2020课程笔记中文版，干货满满！
关注上方"深度学习技术前沿",选择"星标公众号", 资源干货,第一时间送达! [导读]Yann Lecun在纽约大学开设的2020春季<深度学习>课 ...
超级干货丨优美的课程笔记，吴恩达点赞的深度学习课程信息图
吴恩达在推特上展示了一份由 TessFerrandez 完成的深度学习专项课程信息图,这套信息图优美地记录了深度学习课程的知识与亮点.因此它不仅仅适合初学者了解深度学习,还适合机器学习从业者和研究者复 ...
python 慕课课程笔记（一）
python 慕课课程笔记 1.python 是动态语言,而 java 是静态语言.动态语言变量本身的类型时不固定的,而静态语言在变量定义时就必须指定变量的类别. 2. 在python 代码中书写 a ...
NTU 课程笔记： CV6422 regression
0 回顾在NTU 课程笔记:Nonparametric statistics_UQI-LIUWJ的博客-CSDN博客中,介绍了 Spearman Rank Correlation,来判断一对有样本之 ...
CS231n课程笔记翻译
贺完结!CS231n官方笔记授权翻译总集篇发布 - 智能单元 - 知乎专栏 https://zhuanlan.zhihu.com/p/21930884 CS231n课程笔记翻译:图像分类笔记(上) - ...
CS231n课程笔记翻译：图像分类笔记（下）
译者注:本文翻译自斯坦福CS231n课程笔记image classification notes,课程教师Andrej Karpathy授权翻译.本篇教程由杜客进行翻译,ShiqingFan和巩子嘉进 ...
CS231n课程笔记翻译：图像分类笔记（上）
译者注:本文翻译自斯坦福CS231n课程笔记image classification notes,由课程教师Andrej Karpathy授权进行翻译.本篇教程由杜客翻译完成.ShiqingFan对译 ...

Html 课程笔记（1）

CatPhotoApp

字体最大

字号最小
表示强制换行显示，没有结束标签，直接使用
表示标签的开始和结束（单标签） (双标签)

CatPhotoApp

…

、

Html 课程笔记（1）相关推荐

最新文章

热门文章

Html 课程笔记（1）

CatPhotoApp

字体最大

字号最小 表示强制换行显示，没有结束标签，直接使用 表示标签的开始和结束（单标签） (双标签)

CatPhotoApp

…

、

Html 课程笔记（1）相关推荐

最新文章

热门文章

字号最小
表示强制换行显示，没有结束标签，直接使用
表示标签的开始和结束（单标签） (双标签)