JAVA笔记

Java的笔记真的是越看越迷糊,原来还记得的一些东西现在也都是迷迷糊糊,还要下功夫才能记住,而且那些个英文字母真的是难记,真的是想尽办法.

面向对象的三大特征:封装/继承/多态

封装:1.属性私有化
2.生成get&set方法
3.生成有参无参构造
数组的是相同数据类型的集合
定义数组：
      格式：   
1.  数据类型[]  数组名 = new  数据类型[数值];
2.  数据类型[]  数组名 = new  数据类型[]{值1,值2,,,,,,};
3.  数据类型[]  数组名 = {值1，值2，值3，，，，，};
数组的长度：
1.  数组名.length可以直接得到数组的长度
2.      
索引：
     数组中数据的所在位置我们一般使用索引表示，索引又叫做下标，数组的索引是从0开始
数组元素的赋值:
     数组名[下标] = 数据;
基本结构：
 
一、            Object
二、            访问权限修饰符

权限修饰符	在本类中	在同包	不同包继承关系	任何位置
私有的private	√	×	×	×
默认（default）	√	√	×	×
受保护的protected	√	√	√	×
公共的public	√	√	√	√

三、            this
四、            super
五、            final 最终的
六、            static  静态
abstract  抽象的
接口interface
 
多态:（多种状态）
异常
常用的包:
常用的类
String
StringBuffer和StringBuilder的区别
Math
属性：
方法：（所有的方法都是静态方法）
Random（java.util）
日期类(java.util)
包装类
集合：
集合基本结构
Collection
List  有序可重复
Set   无序不可重复
ArrayList，LinkedList，Vector的区别
方法：
HashMap和Hashtable的区别
Iterator迭代器
现在时间凌晨零点三十分,弄完作业又来弄在这个,真是佩服我自己,转变从现在开始.

方法：

     可重复执行的代码块

         修饰符  返回值类型  方法名(参数列表){

              方法体;

}

修饰符： public（公共的），private(私有的)，default（默认，不许要写），protected（受保护的），static（静态的），final（最终的），abstract（抽象的），，，，，

返回值类型：  void（无返回值），数据类型 （包含基本数据类型，也包含引用数据类型）

方法名:符合标识符的命名规则

参数列表：有0个或者多个参数组成参数的组成部分是：

              数据类型参数名，数据类型 参数名，，，，，，

方法的分类：

1.  无返回值，无参数

a)   修饰符   void  方法名(){}

2.  无返回值，有参数

3.  又返回值，无参数

4.  有返回值，有参数

5.  

 

面向过程：

对于面向过程来说，有任何一个环节出现问题，那么将无法得到最终结果

面向对象：

     将所有的事物都看成是一个对象  

     一般来说我们不关心事物的过程，只以对象为基础来研究某事物

将具有共同特征的事物统称为类

 

类的组成部分：

         属性：事物的特征和特性，属于静态特点

                  格式：修饰符  数据类型  属性名;

         方法：事物的行为，动作，动态特点我们称之为方法

                 格式：修饰符  返回值类型  方法名（参数列表）{

                   方法体；

}

构造方法：

         作用：初始化类的信息

         结构：访问修饰符  类名(参数列表){

}

访问修饰符指得是：private  public protected  default

  注意:在加载类时，系统会默认提供一个无参的构造函数，在创建对象的时候会调用构造方法

  当一个类中存在自定义的构造函数之后，系统将不再提供默认的无参构造

全局变量：成员变量

  直接写在类中，方法外部，作用范围是整个类，指的大部分都是属性

局部变量：

  通常是写在方法内部，只适用于当前的方法或者更小的范围，（变量的作用范围就是离它最近的{}内部）

        

this  这，这个，一般用来代指成员变量   例如：this.name指的就是这个对象的name属性即属性name

继承是发生在父子类关系中的

继承的关键字  extends

继承的格式：public class 类名  extends 父类{}

继承的特点：

1.  继承发生在父子类关系中

2.  在java中继承是单继承的（一个类只能继承一个父类）   

3.  但是一个父类可以被多个子类继承

4.  一个类继承了父类，那么它将拥有父类的所有属性和方法，私有属性和方法可以继承，但是不能使用

方法的覆盖（方法的重写）：

a)   在父子类继承关系中，当父类的方法不能满足子类的需求时，子类重写父类的非私有，非静态的同名方法，要求：方法名称相同，参数的个数，顺序，类型必须完全相同，返回值类型也要相同，子类的访问权限不能

b)   小于父类；子类不能抛出比父类更多的异常但可以是父类异常的子异常

super  代表的超级的，父级的

     在创建子类对象时，默认会先执行父类的无参构造，调用父类无参构造的方法：super(),调用父类有参构造：super(参数列表的值);当父类中不存在无参构造时，那么子类必须手动调用父类的有参构造

Object是所有类的父类，类在默认情况下，继承的都是Object类

当我们直接输出一个对象名的时候：会出现：当前类的路径+@+hashcode、

1.    toString()   将对象转化成String类型，在使用对象时，默认会调用toString()方法

a)   toString得到的字符默认格式为：当前类的路径+@+hashcode

b)   若想要呢自己规定格式，那么我们需要重写toString();

c)   

2.     equals()

a)   ==比较基本数据类型时比较的是值是否相等，比较引用数据类型时比较的是内存地址是否相等

b)   equals()比较的是引用数据类型的值是否相等

c)   在object中equals方法只是简单的使用==进行了比较，若我们真的想要比较引用数据类型的值是否相等，那么我们就需要重写equals方法

3.    finalize () 垃圾回收机制  只是用来进行垃圾回收    

 

         访问权限从小到大的顺序为：private  default   protected public

this ，这  这个在代码中一般指的是当前对象，主要用来区分成员变量和局部变量

                            当变量名相同时，加this关键字的指的是全局变量，不加this关键字的是局部变量

                           

this的用法：

                   调用当前类的属性：this.属性名;

                   调用当前类的方法：this.方法名();。。。。。此处的this是可以省略的

                   调用当前类的构造方法：this();…..当调用有参构造时，需要在()中添加参数

super指的是父级的，一般用来调用父类中的特性

super的用法：

                   调用父类中的属性：super.属性名;

                   调用父类中的方法：super.方法名();

                   调用父类中的构造方法：super();……当调用有参构造时，需要在()中添加参数。。。。。。。。。必须写在子类构造函数的第一行

1.        final修饰的类不能被继承

2.        final修饰的属性，值不能改变，是常量，必须赋初始值

3.        final修饰的方法，不能被重写

4.        不能修饰构造方法

能修饰属性，也能修饰方法

使用static修饰的方法和属性，不属于对象，只属于类

 

调用静态属性:类名.属性名;

调用静态方法:类名.方法名();

abstract  可以修饰方法

     修饰的方法我们称为抽象方法；

     修饰的方法没有方法体；

     抽象方法只能存在于抽象类中

abstract修饰类的抽象类

a)   当一个类继承了抽象类，那么这个类就必须重写抽象类中的所有抽象方法

b)   抽象类中可以有抽象方法，也可以有普通方法

c)   抽象类不能被实例化（不能创建对象）

 

a)   定义的格式：

public   interface 接口名{}

b)   接口是特殊的抽象类

c)   接口中所有的方法都是抽象方法，接口中所有的方法都是默认使用public abstract修饰的

d)   接口中所有属性（变量）都是默认使用public static final修饰的，必须给定初始值

e)   接口也不能被实例化

f)    类与接口之间只能是实现的关系，即类实现接口

g)   类实现了该接口，那么就必须重写接口中的所有方法

h)   类是多实现的，即一个类可以实现多个接口，接口之间使用，分割

i)     

j)     类是单继承，多实现的（一个类只能继承一个父类，但是可以实现多个接口）

1.    重载

     在同一个类中，要求方法的名称相同，参数的个数，顺序，类型至少有一个不同

2.    重写，

     在父子类继承关系中，父类无法满足子类的需求时，那么我们需要重写该方法，要求；方法的名称相同，参数相同（个数，顺序，类型），返回值相同；子类的访问权限不能小于父类；子类不能抛出比父类更多的异常，但可以是父类异常的子异常

3.    实现类创建接口对象

a)   接口的特点：

   特殊的抽象类

   所有的方法都是抽象的，公共的，默认的是public abstract

  属性默认是public static  final修饰的，必须赋初始值

  接口与类之间的关系是类实现接口

  一个类实现了该接口，那么必须重写该接口中的所有方法

  一个类可以实现多个接口，但只能继承一个类

  接口不能实例化

格式：     接口  对象名 = new  实现类();  

 在这个对象中可以使用的方法只能是接口中含有的方法，

4.    创建类的子类得到父类对象

a)   抽象类的特点：抽象类的特点，当一个类继承抽象类，那么这个类需要重写抽象类中的所有抽象方法，抽象类中可以有普通方法，也可以有抽象方法

b)   抽象方法的特点：抽象方法没有方法体，抽象方法只能存在于抽象类中

格式：父类  对象 =new  子类();   可以通过new子类来使用父类中的方法    在这个对象中可以使用的方法，都是父类中的方法

error       错误。在程序运行过程中出现的无法解决的错误;最常见的是：内存溢出

exception        在程序运行过程中出现的可以解决的问题

 

 

1.    异常的分类：

   一般异常（受控异常）：

 在代码编译过程中，得到可能出现异常的位置，必须解决后才能编译通过

1.    IOException、Io流异常

2.    FileNotFoundException：文件未找到异常

3.    EOFException：读写文件尾异常

4.    MalformedURLException：URL格式错误异常

5.    SocketException：Socket异常

6.    SQLException   sql异常

7.    ParseException  日期格式转换异常

b)   运行时异常：RuntimeException（非受控异常）：

  程序的运行过程中，可以编译通过，但是由于代码逻辑问题出现的异常，我们称之为运行时异常

1.    常见的运行时异常：

a)   ArrayIndexOutOfBoundsException   数组下标越界异常

b)   IndexOutOfBoundsException 下标越界异常

c)   StringIndexOutOfBoundsException  字符串下标越界异常

d)   ArithmeticException  数学计算异常

e)   NullPointerException 空指针异常

f)    NumberFormatException         数字格式化异常

c)   异常的解决方案：

               i.         try catch格式：

try{

                       可能出现异常的代码块

}catch(异常的类型){

     异常的解决方式

}

当我们写多个catch的时候，顺序应该为异常从小到大

finally是try catch的连用语句，表示是否出现异常都会执行finally里面的内容，一般我们用于关闭连接，释放资源

     ii.        throws   抛出，声明异常

1. 一般在方法的()后面声明异常一个，一般情况下，我们会将异常抛出给main方法，注意，在main方法中必须使用try，，catch块解决

 

 

 

请写出final，finally，finalize的区别

请写出重写和重载的区别

 

重载是在同一个类中,重写是在父子类继承中.

重载中要求参数至少一个不一样,重写要求非私有,非静态的方法,而且名称参数要相同.

1.  java.util(工具包)         

2.  java.lang(默认路径的包)

3.  java.io(文件流)

4.  java.sql(数据库包)

1.  创建String类型的数据

a)   String  变量名 =new  String();

b)   String  变量名 =new     String(“字符串”);

c)   String  变量名  = “”;

2.  String类的常用属性和方法

a)   length()   数组的长度

               i.         

b)   charAt(index)   根据下标找字符

               i.         

c)   indexOf(Str)  根据字符找下标（从左到右找到该字符第一次出现的下标）

d)   indexOf(String str,int fromIndex)  从指定的位置开始查找该字符第一次出现的位置

               i.         

e)   lastIndexOf(String str)     根据字符找下标（从右往左查找该字符第一次出现的下标）

f)    lastIndexOf(String str ,fromIndex) 根据字符找下标（从指定的位置开始从右往左查找该字符第一次出现的下标）

               i.         

g)   replace（String oldStr ,String  newStr）  字符串替换

h)   split(String str)   使用指定的字符，分割字符串，得到相应的字符串数组

i)     concat(String str)  字符串拼接

j)     contains(String str)  字符串是否包含指定字符（结果为boolean类型的）

k)   equals(“”)     比较两个字符串是否相等，得到的结果是boolean类型

l)     subString(int beginIndex)  从指定下标开始截取，直到字符串结束

m) subString(int beginIndex，endIndex)从指定下标开始截取到指定位置

n)   toLowerCase()  将大写转化为小写

o)   toUpperCase()  将小写转化为大写

p)   

 

拥有共同的方法，toString(),append()字符串追加的方法

 

1.  String字符串的长度是固定不变的，而StringBuffer和StringBuilder来说可变的字符串，所以说一般情况下涉及到字符串拼接我们都使用StringBuffer或者StringBuilder

2.  StringBuffer是线程安全的，运行效率低于StringBuilder

3.  StringBuilder是非线程安全的，适用于单线程，运行效率高于StringBuffer

 

结果为：3.141592653589793

1.  abs();   绝对值

2.  round()   四舍五入

3.  ceil()        上取整

4.  floor()      下取整

5.  random()      随机数

1．     nextInt()       取int范围内的随机数

2．     nextInt(n)   取值范围0~n包括0 ，不包括n

 

1.  创建时间对象  Date date   = new Date();可以得到当前时间

getTime()  1970至现在的获得时间的毫秒值(使用方法:对象.方法)

2.  创建时间格式化对象  SimpleDateFormat sim =new  SimpleDateFormat(“字符串格式”);

a)   yyyy  代表的是4位的年

b)   yy代表的是年份的最后两位

c)   MM代表的是月份

d)   dd 代表的是日期

e)   hh代表的是小时

f)    mm代表分钟

g)   ss代表的秒

h)   format()  将日期格式转化为字符串类型

i)     parse()将字符串转化为日期类型，

基本数据类型的包装类(基本数据类型和包装之间是可以自动进行相互转化的)

  基本数据类型         包装类

  byte                Byte  

  short               Short

  int                 Integer

  long                Long

  float              Float

  double              Double

  char                Character

  boolean             Boolean

 

 需要记住的方法  valueOf()   直接包装类.valueOf()可以将String类型的数据转化为指定的包装类

  parse基本数据类型();  使用方式：包装类.parse基本数据类型(),直接将String类型转化为指定的基本数据类型

                       

Collection是所有集合的顶层接口，包含了List和Set接口，

List有实现类ArrayList，LinkedList，Vector

         Set有实现类HashSet  TreeSet

     集合优点：一般用来存储对象，没有长度限制，不需要在创建集合时就赋予长度，可以存储任何类型

     常用方法:

         add()           向集合中添加元素

         size()           获得集合的长度

         remove()      移除集合中的指定元素

     List的常用方法：

          add()  向list集合中添加数据

         size()  求取list集合的长度

         remove(object) 根据内容移除

         remove(index)  根据下标移除集合中的元素

get(index)  根据下标获得集合中的指定对象

set(index,val)  根据下标，重新设置某元素

     常用方法：

          add();   向set集合中添加一个元素

         remove() 移除set集合中的指定元素，根据内容移除

         size()      获得set集合的长度

 

             

     ArrayList基于数组存储结构：查询速度较快，插入和删除速度较慢，线程不安全的

     LinkedList基于链式存储结构：查询速度较慢，插入和删除速度较快，线程不安全的

     Vector 线程安全的，但是已不建议使用

 

Map是由键对象和值对象组成的

Map的格式：<key,value>

Map要求：键对象不能重复，值对象可以重复，key是唯一的；

key和value的数据类型没有限制

         put(key，value)     向map映射中添加数据

         size()                    获得map映射的长度

         get(key)                根据key获得所对应的value值

         values()                获得所有的值

         keyset()                获得所有的键对象（得到一个set集合）

1.  继承类不同：

a)   HashMap继承 AbstractMap

b)   Hashtable继承Dictionary

2.  执行效率不同：

a)   HashMap是非线程安全的，是Hashtable的轻量级实现，效率较高

b)   Hashtable是线程安全的，效率较低

3.  put方法对key和value的要求不同

a)   HashMap允许entity( 实体类)的key或者value  为null《HashMap允许有空值》

b)   Hashtable不允许entity的key或者value为null，否则会出现NullpointerException

 

 

 

 

睡觉睡觉