Html 课程笔记（1）

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  )

1. abstract class abstrctIt {

2.   abstractfloat getFloat ();

3. }

4. public class AbstractTest extends AbstractIt {

5.   privatefloat f1 = 1.0f;

6.   privatefloat getFloat () {return f1;}

7. }

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();

f.

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、D