Java基础笔记

Java

起源: James Gosling(JAVA之父)    1955.05.23

 

JAVA 特点

a).简单性:(自动内存分配和回收)单一继承

b).面向对象:(OOP)

c).分布式

d).健壮性:(垃圾回收机制，有效的防止内存泄露)

e).安全性：

f).平台无关性：（跨平台）

g).可移植性：

h).多线程：

 

ＪＡＶＡ虚拟机：                                 

ＪＡＶＡ源文件→ＪＡＶＡ编译器→字节码文件→ＪＡＶＡ解释器→ＣＰＵ

 

ＪＡＶＡ开发工具包：

Ｂｉｎ目录：存放可执行文件．（应用程序）

Ｌｉｂ目录：存放ｊａｖａ的类库文件（基础类库）

Ｄｅｍｏ目录：存放演示程序．（事列）

Ｊｒｅ目录：存放ｊａｖａ运行环境文件．（运行环境）

 

配置方法：

＂我的电脑＂→＂系统＂→＂环境变量＂→＂用户变量＂

＂ｐａｔｈ＂→ｊａｖａ　Ｂｉｎ目录所在文件物理地址

新建→＂ｃｌａｓｓｐａｔｈ＂→＂．；＂→＂确定＂

 

类名：

由字母，数字，下划线＿，＄构成

不能由数字开头

第一个字母大写

和文件同名

 

编译：ｊａｖａｃ　文件名．ｊａｖａ

运行：ｊａｖａ　文件（类名）

 

注释：

实现注释：＂／／＂和＂／＊　　＊／＂

文档注释：＂／＊＊　　＊／＂

 

数据类型；

原始数据类型：（八种）

ｂｙｔｅ，ｓｈｏｒｔ，ｉｎｔ，ｌｏｎｇ，ｆｌｏａｔ，ｄｏｕｂｌｅ，ｃｈａｒ，ｂｏｏｌｅａｎ

引用数据类型：（三种）

数组，类，接口

 

默认值：

bｏｏｌｅａｎ　  ｂｙｔｅ　  ｓｈｏｒｔ　  ｉｎｔ　     ｌｏｎｇ

ｆａｌｓｅ　      　０　　　　　　０　　　　  ０　　　    ０　　

ｆｌｏａｔ　      ｄｏｕｂｌｅ　        ｃｈａｒ　　　　　　  引用

０.００ｆ　　　　　　　              ＇＼ｕ００００＇　　　ｎｕｌｌ

 

变量:

存储数据的基本单元

命名规则:

由字母,数字,下划线,$符号组成;必须以字母,下划线,$符号开头;

不能为关键字;第一个单词的首字母小写,其后单词的首字母大写

 

标识符:变量,函数,数组,对象,类,接口等

 

变量的作用域和生命周期:

变量何处使用何处声明

作用域:一对{  }之间

 

类型转换:

1.  自动类型转换:

a:两种类型必须兼容

b:目标类型必须大于源类型

如：byte→ short →int →long →float→ double

2.强制类型转换

 

运算符: (操作符)

对数据进行计算和处理或改变特定对象的值

 

操作数的数目:

 一元运算符:如++,--；  二元运算符:如+,-；  三元运算符:如?:

 

数据的操作数:

算术运算符(数学运算)    ；赋值运算符(符号运算符)即右给左

关系运算符 ==,!=,>,<,>=,<=  ；逻辑运算符 &&,||,!   ；位运算符

 

流程控制(控制流)

选择:if和switch语句

Switch(switch-expression){

   ……

}

Switch-expression 必须能计算出一个char,byte,short或int类型的值

 

数组:

基类型数据->栈

引用数据类型->堆

栈:   a.自动申请,自助释放:生命周期同作用域

      b.局部变量,形式参数;通过变量名访问

堆    a.手动申请,手动释放;生命周期由程序控制

      b.通过指针访问

 

声明数组:

数组元素类型数组名[]或数组元素类型[] 数组名

创建数组

  数组名=new 数组元素类型[数组元素个数]

 

数组长度:数组名.length

 

接受单个数: Scanner sc=new Scanner(System.in)

         int num=sc.nextInt()

接收字符串:

  String srry=sc.next.nextLine()

 

命令行参数:

1.  输入的参数以字符串形式提供给main方法使用

2.  可以输入参数也可以不输入

3.  每个字符串以空格隔开

4.  若字符串中包含空格就用双引号引起来

 

类和对象

 面向对象(OOP)

 三大原则:

a.  封装

b.  继承

c.  多态

对象:属性与方法的封装体

Java中创建对象的步骤:①分配空间②初始化属性③调用构造方法

 

三大特征:

1.  行为

2.  状态

3.  标识

类:具有相同属性和方法的一组对象的集合

类的定义:

  [修饰符] class 类名 [extends 父类名] [implements 接口名]{

  类主体

}

 

类中的方法:

  方法的定义:

[访问修饰符] 方法返回值的数据类型 方法名称([形参表]){

 方法体

}

 

访问修饰符:

private  :仅本类成员可见

default  :本类＋同包类可见（默认）

protected:本类＋同包＋不同包的子类

public   :公开

完全封装：属性全部私有，并提供相应的get/set方法。

get方法:无参数;由返回值

set方法:由参数:无返回值

 

构造方法:

1.  与类名相同,在对象实例化时,自动引用

2.  没有返回值

3.在不写构造方法时，系统会自动生成一个无参的构造方法。

 

定义:

 [访问修饰符] 类名(){

  方法体

}

 

方法重载:

三大原则: (与有无返回值,返回类型无关)

a.  方法名相同

b.  参数相同:数据类型,个数,不同数据类型排序不同

c.  作用域相同

 

This引用:

 作用:

a.  每个成员都隐匿了一个this,这个this指向的是当前调用的这个方法的对象

b.  当成员属性名和形参或者局部变量同名时,可使用this区分

c．this()表示调用本类的其他构造方法，且只能放在一个方法中的第一行第一句。

Static: (修饰成员)

静态成员不属于一个对象,被所有对象共享

在静态方法中不允许调用本类中的非静态成员

静态成员生命周期:整个程序(类加载到虚拟机开始)

程序中主类的静态变量会在main方法执行前初始化。

静态成员变量只能初始化一次

 

包:

创建包:

 Pack 包名;(位于程序的第一行)

导入包:

Import 包名;

 

继承;

 子类可以共享父类的成员方法及成员属性,但父类不能访问子类的成员

子类不能够继承父类的构造方法

 

super关键字

1．              Super（）表示调用父类的构造方法

2．              Super（）也和this一样必须放在方法的第一行第一句。

3．              Super.表示调用父类的方法或属性。例：super.m();

4．              Super可以屏蔽子类属性和父类属性重名时带来的冲突

5．              在子类的构造函数中如果没有指定调用父类的哪一个构造方法，那么就会调用父类的无参构造方法，即super（）。

 

定义:

[类修饰符] class 子类名 extends 父类名

Java中继承为单一继承,即一个子类只能继承一个父类,但一个父类可被多个子类继承

 

若两个类有继承关系在调用构造方法时,会先调用子类自己的构造方法

如果父类和子类由同名的成员属性,子类调用本身的成员属性

 

多态:同一函数,多种形态.

方法重载:两个类有继承关系,两个类中方法可以重载

 

覆盖（Override）:参数表、方法名必须完全相同，访问修饰符要求子类宽于父类。

子类覆盖父类方法只能在子类中通过super.方法调用父类方法

引用转型:父类的引用指向子类实例(对象)

 

Person p =new Student()

引用          对象

p.eat()调用子类方法

若Student类中不存在eat方法,则调用Person中eat方法

 

成员属性与引用相同

方法与对象相同

 

静态方法不能被覆盖,静态方法跟引用相同

当方法中行参为父类引用,可传任意子类对象

 

Final:

修饰:

a.  类:不可被继承

b.  成员方法:不能被子类覆盖

c.  变量:(成员变量,局部形参)变量名用大写字母,为常量,不能改变

 

If(对象 instanceof 类名){

  ………

}判断对象是否为类的一个实例

instanceof一般用于在强制类型转换之前判断对象变量是否可以强制转换为指定类型。

 

abstract修饰符

1．              可用来修饰类、方法

2．              abstract修饰类时，则该类成为一个抽象类。抽象类不可生成对象，必须被继承使用。

抽象类可以声明，作为编译时类型，但不能作为运行时类型。

Abstract永远不会和private,static,final同时出现。

3．              Abstract修饰方法时，则该方法成为一个抽象方法，抽象方法没有实现只有定义，由子类覆盖后实现。

4．              抽象方法从某中意义上来说是制定了一个标准，父类并不实现，留给子类去实现。

 

接口（interface）

1、              定义：接口不是类，而是一组对类需求的描述，这些类要遵从接口描述的统一格式进行定义。定义一个接口用关键字interface。

2、              接口是一种特殊的抽象类。在一个接口中，所有的方法为公开、抽象的方法，所有的属性都是公开、静态、常量。所以接口中的所有属性可省略修饰符：public static final，接口中所有的方法可省略修饰符：public abstract。

3、              （1）一个类实现一个接口必须实现接口中所有的方法，否则其为一抽象类。并且在实现类中的方法要加上public(不能省略)。实现接口用关键字implements. 所谓实现一个接口就是实现接口中所有的方法。

(2) 一个类虽只实现了一个接口，但不仅要实现这个接口的所有方法，还要实现这个接口 继承的接口的方法，接口中的所有方法均须在类中实现。

4、              一个类除了继承另一个类外（且只能继承一个类），还可以实现多个接口(接口之间用逗号分割)。这样可以实现变相的多继承。

5、              不能用“new 接口名”来实例化一个接口，但可以声明一个接口。

6、              接口与接口之间可以多继承。

 

接口 VS 抽象类

1、接口中不能有具体的实现，但抽象类可以。

2、一个类要实现一个接口必须实现其里面所有的方法，而抽象类不必,但是不全部实现抽象类中的抽象方法的子类还是一个抽象类。

3、通过接口可以实现多继承，而抽象类做不到。

4、接口不能有构造方法，而抽象类可以。

5、实体类与接口之间只有实现关系，而实体类与抽象类只有继承关系，抽象类与接口之间既有实现关系又有继承关系。

6、接口中的方法默认都是公开抽象方法，属性默认都是公开静态常量，而抽象类不是。

Error表示系统级的错误和程序不必处理的异常，

Exception表示需要捕捉或者需要程序进行处理的异常。

 

异常:

  Try{

  可能发生异常的代码块

}catch(异常类型1 异常对象名1){

  异常处理代码1;

}catch(异常类型2 异常对象名2){

 异常处理代码2;

}

  ……{

}finally{

  无论是否抛出异常都要执行的代码;

}

 

Catch语句中,层次越高越往下写,层次越低越往上写.

 

异常类型:

a.  编译异常

b.  运行异常

  

Throwable:

a.  Error

b.  Exception

1. ClassNotFoundException

2. IOException

3. RuntimeException

 

Throw throws

[修饰符] 返回类型 方法体 (参数1,参数2,  ……)throws 异常列表{

  方法体

}//声明异常

 

自定义异常类:

Class 自定义异常类名 extends Exception{

    ……

}

 

抛出异常

  Throw new 异常名(“  ……”)

 

 

Lang包:

基本数据类型:

char byte short int long float Boolean

包装类:

Character Byte Short Integer Long Float Boolean

 

包装类的构造方法: (value需强制转换)

Character(char value)

Byte(byte value)        Byte(String s)

Short(short value)      Short(String s)

Integer(int value)      Integer(String s)

Long(long value)        Long(String s)

Float(float value)      Float(String s)

Double(double value)    Double(String s)

Boolean(Boolean value)  Boolean(String s)非true均为flase

注意:当s超过取值范围或包含非数字字符时均报错

 

包装类的方法:

包装类.valueof(String)

包装类.parse基本数据类型(String)

 

Character.isLetter(char ch) 判断是否为英文

Character.isDigit(char ch)   判断是否为数字

Character.isWhiteSpace(char ch) 判断是否为空格

 

String类

New一个String对象创建了两个对象(堆对象,缓冲区对象)

创建一个String常量创建了一个对象(常量池)

 

= =运算符用于比较两个引用是否指向同一对象,即两个引用数据类型比较,为地址值的比较

 

String类的构造方法:

String()  初始化一个新String对象,使其包含一个空字符串

   String(char[] value)  分配一个新的String对象,使它代表字符数组参数包含的字符序列

 

字符串比较

判断两个字符串是否相等:s1.epuals(s2)

按字符顺序比较字符串大小: s1.compareTo(s2)

    S1<s2,返回-1;s1>s2.返回1;s1=s2,返回0

数组的长度为一个属性;str.length

字符串的长度为一个方法.s.length()

 

搜索字符串:

S1.indexOf(int char)或s1.lastIndexOf(int char)

   返回s1中字符char第一次或最后一次出现的位置

S1.indexOf(s2)或s1.lastIndexOf(s2)  返回字符串s2在s1中第一次或最后一次出现位置,不包含返回-1

提取字符串:

S1.charAt(int index) 返回s1中index个所对应的字符,index为下标号

S1.subString(int beginIndex) 返回s1中beginIndex位置开始的子串

S1.substring(int beginIndex,int endIndex) 返回s1中从beginIndex到endIndex位置结束的子串,不包括结束索引

 

S1.replace(oldChar,newChar)用newChar替换oldChar

S1.replace(String s2,String s3)用s3替换s2字符串

 

 

更改字符大小写:

S1.toUpperCase() 转换成大写字符

S1.toLowerCase() 转换成小写字符

 

StringBuffer类

StringBuffer构造方法:

  StringBuffer():构造一个空的缓冲字符串

StringBuffer(String str):构造一个缓冲字符串,初始化为字符串str

 

常用方法:

 S1.append(String s2) 将s2加到s1之后

S1.insert(int offset,String s2)在s1从offset处开始插入字符串s2

S1.setCharAt(int index,char ch)用ch替换s1中index位置上的字符

S1.replace(int start,int end,String s2)s1中start位置(含)开始到end位置(不含)结束之间的字符串以s2代替

S1.delete(int start,int end)删除s1中从start位置(含)开始end位置(不含)结束之间的字符串

S1.deletCharAt(int index):删除s1中index位置的字符

 

System类

arryCopy(源,源开始位置,目标,目标开始位置,复制长度)

exit(0或1)  终止java虚拟机

    0:正常退出    1:异常退出

 

Math类  静态方法

 常量:

a.  double E :自然底数常量e

b.  double PI ：圆周率常量

 

random() 随机数

ceil(double a) 大于等于的最小整数

floor(double a) 小于等于的最大整数

pow(double y,double x) 返回y的x次幂

abs(int a) 返回|a|

max(int a,int b)返回a和b的最大值

min(int a,int b)返回a和b 的最小值

 

Object类

1、              object类是类层次结构的根类，他是所有类默认的父类。

2、              object类中的三个方法。

（1）、finalize()

        当一个对象被垃圾收集的时候，最后会由JVM调用这个对象的finalize方法；

（2）、toString()    返回一个对象的字符串表示形式。打印一个对象就是打印这个对象toString方法的返回值。

        在自己的类时覆盖toString()方法，从而打印需要的数据。Public String toString(){……}

(3)、equals(Object o)

        该方法用来判断对象的值是否相等。但前提是类中覆盖了equals方法。Object类中的equals方法判断的其实还是地址。

（4）、equals的特性：自反性、对称性、一致性、传递性。

 

until包

Date类:

创建一个对象

 Date 对象名=new SimpleDateFormat(String pattem)

调用 format(Date date)

Calendar类

创建对象:

Canlendar 对象名=Calendar.getInstance()

 

集合(动态数组)

ArrayList类  线性结构:内存地址相邻,方便查询,不利于删除

创建对象:

ArrayList 对象名=new ArrayList( )

对象.clear():清除所有元素

对象.isEmpty():判断一个集合是否为空

对象.contains(元素)：判断集合中是否存在该元素

对象.remove():

1.     remove(int index)：指定索引删除

2.     remove(object obj):指定对象删除

对象.add(元素)：向集合中添加元素

对象.add(object obj,0)尾部添加元素

对象.add(int index,object obj ):在index位置插入obj

对象.size():集合的长度

对象.get(int index):返回指定索引位置的元素（索引从0开始）

 

对象.iterator( ):返回一个Iterator的迭代器对象

Iterator对象.hasnext( ):判断是否有下一个元素，返回boolean值

Iterator对象. next( ):返回下一个元素（Object类型）

 

Collections.sort(集合对象):对集合进行排序

Collections.reseve(集合对象)：对集合进行反转

Collections.shuffle(集合对象)：随机更改指定集合元素的序列

 

Arrays类：对数组进行排序

Collections类:对集合进行排序

 

对象进行排序可通过实现Comparable接口实现，重写ComparTo( )方法

ComparTo( )方法：返回值int类型，参数Object对象

 

LinkedList类：

链表结构：

LinkedList 对象=new LinkedList（）

对象.add(元素)：添加元素

对象.addFrist(元素)：添加元素到第一位

对象.addLast(元素)：添加元素到末尾

对象.clear():清空所有元素

对象.removeFirst()：移除并返回第一个元素

对象.removeLast():移除并返回末尾的元素

对象.peek(元素)：找到不移除

对象.poll(元素):找到并移除

 

HashMap类

键值对：(Key-value)

HashMap 对象=new HashMap()

对象.clear():清除所有键值对

对象.containsKey(object obj):清除指定键的键值对

对象.containsValue(object obj):清除指定值的键值对

对象.get(object key)：返回指定键所对应的值

对象.size():键值对的个数

对象.put(key,value):添加键值对

对象.KeySet( ):返回Set对象 Set中包含

HashMap类没有分类或者排序。它允许一个null键和多个null值

HashMap中若新增的键已经存在，则新值覆盖原来的值

 

HashMap可以通过Iterator迭代器进行输出

迭代HashMap：HashMap对象.keySet( )→Set对象. Iterator( ) →Iterator对象.hasNext( ) → Iterator对象.next( )

 

判断HashMap的键是否重复：（通过下列两个方法判断）

Equals( ):判断元素是否重复，返回boolean值

HashCode( ):返回hashCode码，int值

 

HashSet与HashMap相同点：

元素不能重复，元素无序存放

 

JDBC

ODBC:

导入驱动包：

   “project” →”properties”→”librries add external”→ 选择驱动包

Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

connection=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;databaseName=数据库名","登录账号","密码");

 

查询方法：executeQuery( )

增删改：executeUpadate( )

 

Connection.SetAutoCommit(boolean):设置SQL语句是否自动提交

Connection.rollBack():回滚

执行存储过程语句对象 CallableStatement

CallableStatement对象= Connection.prepareCall(sql)

SQL语句写法： sql=”{call 存储过程名（参数列表）}”

(参数列表页可采用预编译的形式，同prepareStatement)

注册一个输出参数：CallableStatement. registerOutParameter(int index(参数位置)，Types.__(参数类型))

 

ResultSetMetaData元数据

RSMD对象.getColumnCount（）：获得列数

RSMD对象. getColumnName(int index):通过索引获得列名