Java基础知识学习笔记总结

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

         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

    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 listobj = list;//成立

    List