java基础

Java入门与环境搭建

1. java语言分类：j2se,j2me,j2ee

j2me->安卓

2. Java跨平台性

一次编译，处处运行。因为每个操作系统都有jvm，平衡了操作之间的差异，可以运行.class文件

垃圾回收

3. 程序员无法精确控制和干预

4. Jdk和jre

Jdk：Java开发工具包

Jre：Java运行环境

Jdk中包含jre。Jdk中bin文件夹下都是java命令，例如javac,java命令

5. 程序安装

建议安装目录不要有中文，空格，特殊字符（@，$），原因是当读文件的时候可能会发生转义找不到文件。例如空格会转义成

6. java环境变量的配置

JAVA_HOME,PATH

JAVA_HOME是java安装路径

PATH %JAVA_HOME%\bin

Path这样做的好处是，万一JAVA_HOME路径发生改变，

JAVA_HOME不是必须配置的。在web时，会用到这个变量

 

上面的环境变量是针对某一用户的，下面的环境变量是针对系统的，系统有多少用户都可以使用

7. Java开发步骤

a) 编写.java文件

b) 把.

c) 运行.class文件java +文件名（不带后缀）

 

 

变量与运算符

1. 合法标识符规则

由26个英文字母大小写，数字：0-9 ，_或 $ 组成  

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格

2. Java中的名称命名规范

包名：多单词组成时所有字母都小写：xxxyyyzzz

com.hp.onlinexam.login.dao

类名接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

ITeacherDao，CharacterEncodingFilter

变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

int id，String name

3. 变量分类

成员变量，局部变量

4. 数据类型

基本数据类型（8种）和引用数据类型（3种）

Byte short int long float double char blooen

数组 类 接口

基本数据类型由小到大记

数据类型转换，有小到大自动转，由大到小需强制

Boolean不能和其他转换

当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型

5. 运算符

/：取整

%：取余

++，--运算

=和==区别

&&和||

三元运算符

 

 

 

顺序结构及条件结构

1. Scanner类

Scanner sc = new Scanner(System.in);

数据类型（引用数据类型，类类型） 变量名 = new +类名（System.in）；

sc.nextInt()可以从控制台接收一个int类型的变量

sc.nextLine()可以从控制台接收一个String类型的变量

2. 类的完整的名称：包名+类名

为什么要使用包（package）？

防止有重名的类

方便类的管理

3. If语句 

If可以没有else

If…else if…else，else if可以有多个else if后可以跟表达式

 

 

If或者else中，如果只有一句，{}可以省略

If..else语句可以嵌套

4. Switch语句：

a) switch里的表达式和case后的变量做比较，如果没找到合适的值，执行default语句

b) 2.找到合适的值，执行值对应的代码块。如果有break，则跳出。如果没有，继续往后执行

c) break不是必须的，案例见SwitchScore.java

d) switch表达式支持的数据类型：int, byte, char, short, 枚举, 字符串String

 

 

 

Day4 while do while

1. If（布尔类型表达式）语句else if（布尔类型表达式），boolean类型的表达式：

if(true)—一般表达式不会直接写true,false，而是一个变量，或者通过比较运算符组成的条件，eg:a>0或者多个比较运算符组成的条件：eg:a>=0 && a<=100

while（布尔类型表达式）：while的表达式可以用true

switch（表达式）：byte,short,int,char,enum,String

2. 运行方式

如果是web项目，运行方式是run/debug on server

如果一个类带有main方法，是可以使用java application运行的

Run/debug：run可以直接运行出结果，debug可以关注中间过程。

如果想关注代码的中间过程，例如某一行代码的变量的内容，在这行左侧蓝色区域双击，会出现一个“点”，叫断点。有了断点后，可以用debug->java application运行代码。入口是main方法，从main方法开始执行，一直运行到打断点的行暂定。你可以观察中间过程，按F6，按行执行代码。按F8，跳转到下一个断点。如果想让程序一直执行到结束，可以双击断点，把断点去掉。按F8，直到程序结束。

 

点击java，回到java透视图

 

 

 

For循环

1. for (初始表达式; 条件表达式; 迭代表达式)

{

循环语句;

}

表达式如果不满足条件表达式，无法进入循环eg:for(int i=0;i>100;)

死循环eg:for(int i=0;i<10;i--),for(int I =9;i>0;i++)

迭代表达式在循环语句执行完毕后，对迭代的值修正

2. While,do while for适用场景

While适用于迭代次数不固定的场景

Do..while,后要有分号，先做一次循环，然后判断条件是否成立

For循环，适用于迭代次数固定的场景

3. Break和continue区别

Break:用于switch语句时，跳出分支语句。循环语句的时候用于跳出循环

Continue只能用于循环语句跳出本次循环

 

 

 

类和对象

1. 成员变量 vs 局部变量

相同点：

a) 遵循变量声明或定义的格式： 数据类型 变量名 = 初始化值

成员变量，可以不初始化。如果不初始化，当创建对象的时候系统初始化。

局部变量必须显示的初始化

b) 都有作用域

成员变量作用域是类

局部变量作用域是方法

出了作用域，无法使用

不同点：

1. 声明的位置的不同 ：

成员变量：声明在类里，方法外

局部变量：声明在方法内，方法的形参部分，代码块内

2. 成员变量的修饰符有四个：public private protected 缺省（default）

局部变量没有访问修饰符

Private类型成员变量，在本类中可以访问

当brand改为public权限，可以访问

2. 类的结构

[< 修饰符>] class < 类名> 

{

    [<属性>]

    [<构造构造方法>]

[<方法>]

｝

[]表示可选

成员变量：

[<修饰符>]  类型  <属性名> [=初值] ; 

变量必须先定义后使用

成员变量在对象创建的时候由系统初始化

方法：

<修饰符> <返回类型> <方法名>([< 参数表>]) {

    [< 语句>]

} 

public class Person {

private String name;

// age保存的年龄

private int age;

private int sex;

 

public void study() {

System.out.println("studying");

}

}

3. 对象的创建：

使用构造方法创建：类型（类名） 对象名 = new 类名（）

通过对象调用成员变量或方法

对象成员变量有什么用？记录对象成员变量的信息，不同对象表现不同。

P1.name=”张三” p2.name=”李四”

Car1.color=”red”，car2.color=”blue”

4. 参数传递

基本类型传值，对象类型传地址 

 

 

 

 

Day7封装

1. 封装的好处：

1) 隐藏对象的成员变量

2) 成员变量的访问，通过get/set方法访问

3) 读写可分离，通过设置访问权限

4) 隐藏具体的实现细节

2. Get/set方法命名规范

get/set+成员变量

方法名符合命名规范

public int getAge(){

return age;

}

public void setAge(int param)

。。

}

3. 类中成员变量访问权限一般设置成private，通过get,set方法访问

4. 构造方法

生成对象,new+构造方法

初始化成员变量

构造方法名和类名相同，无返回值（对比普通方法定义）

public class Person2 {

public Person2(){

}

}

如果类中没有定义构造方法，系统提供无参的构造方法。如果定义了，都不提供

Person2 p = new Person2();

Date d = new Date();

5. 构造方法重载

方法名相同，参数列表（参数个数，参数类型）不同

public Person2(){

}

public Person2(String name, int age){

}

6. 构造方法初始化成员变量

可以使用this.成员变量名来访问。如果成员变量名和构造方法形参名一样，必须使用this.成员变量名访问

public Person3(String name, int age){

this.name = name;

this.age = age;

}

7. 构造方法之间的调用

类有多个成员变量，，构造方法有重载。参数多的构造方法可以调用参数少的构造方法。可以使用this关键字调用参数少的方法。可以传参。This必须写在第一行

public Person3(String name, int age){

this.name = name;

this.age = age;

}

 

public Person3(String name, int age, String sex, String home){

this(name,age);

this.sex = sex;

this.home = home;

}

 

 

Day9多态

1. 多态

表现：重载，重写

优点：重载：同一个名字多个方法可以使用。不用再起另外的名字

重写：子类对象可以表现为不同于父类的行为。通过声明为父类，定义为子类，少写很多代码

2. 重载

在同一类中。在不同类中方法名相同，参数列表不同不构成方法重载 方法名相同 参数列表不同：参数个数，参数类型不同

系统会根据参数个数和类型自动匹配应该调用哪个方法

只根据方法的返回值，无法判断方法重载

因为方法虽然有返回值，但是可以不接收

java无法判断改掉用哪个方法

public int add(int i, int j) {

return i + j;

}

public double add(double i, double j) {

return i + j;

}

public int add(int i, int j, int k) {

return i + j + k;

}

3. 重写

重写：父类方法满足不了子类要求

返回类型相同

方法名相同

参数列表相同

访问权限：不小于父类方法

父类是default，子类可以是protected,public

public class Person {

private String name;

private int age;

public String getInfo() {

return "Name: " + name + "\n" + "age: " + age;

}

}

public class Student extends Person{

private String school;

public String getInfo(){

return "Name: " + getName() + "\n" + "age: " + getAge()+"\nschool:"+school;

}

public static void main(String [] args){

//当创建的是子类对象时，调用的是子类的方法

Student s = new Student();

System.out.println("创建子类对象："+s.getInfo());

//当创建的是父类对象的时候，调用的是父类的方法

Person p = new Person();

System.out.println("创建父类对象："+p.getInfo());

Person p2 = new Student();

System.out.println("调用的是哪个对象的方法："+p2.getInfo());

}

}

4. 重载和重写

重载针对同一个类中不同的方法，方法名相同，参数列表不同

重写：父类的方法满足不了子类要求，子类重写父类的方法，方法名，参数列表，返回类型都相同

5. Final关键字

1) Final修饰的类不能被继承，例如String

2) Final修饰的方法不能被重写：

public class Person {

public final String getInfo(){}；

}

public class Student extends Person{

//报错

public String getInfo(){

}

}

3) Final修饰的基本数据类型变量，初始化不能被修改

public class FinalVariableTest {

//final修饰的基本数据类型变量，初始化后不能被修改

final int aa = 5;

public void change(){

// aa = 10;

}

}

4) Final修饰引用数据类型变量，地址不能被修改，即不能把一个其他变量赋值给它。

public void tune(final Instrument in){

// in = new Instrument();形参是final类型，不能改变地址

in.setNote("music3");

in.play("music");

}

 

6. Static类型关键字

可以修饰变量，也可修饰方法

Static修饰变量，成为类变量。类变量中所有对象共享一套数据，类名.静态变量名

Static修饰方法：所有对象共享，类名.静态方法

在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。

静态方法不能以任何方式引用this关键字。因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。

main() 方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员。

随着类的加载而加载，只加载一次

类属性作为该类各个对象之间共享的变量。

 

 

 

 

Day10 抽象类和接口

1. 抽象类

类可以定义为抽象类

有抽象方法的类都是抽象类

抽象方法应用场景：

1) 方法的实现没想好

2) 无法统一子类的实现

如果父类中有抽象方法，子类不实现，子类必须为抽象类

抽象类不能被实例化

2. 抽象类不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法

1) 属性：Abstract只能修饰类，方法。属性（成员变量）都有具体的值。

2) 私有方法：如果能修饰，子类可以实现私有方法。私有方法只有本类能访问到，子类没有访问权限，既然不能访问就不能实现，子类必须定义为抽象类，子类继承类也必须是抽象类。子类中没有类能定义为非抽象类，无法用构造方法创建对象。

3) 构造方法：构造方法特点：和本类类名相同。构造方法在子类中不能被重写。如果能够修饰构造方法，构造方法在父类中只有声明，需要在子类中重写。所有不能修饰，矛盾

4) 静态方法：静态方法调用规则：类名.静态方法。如果能修饰，静态方法只能声明，不能有实现。矛盾

5) Final：final修饰的方法，不能被重写。如果用abstract修饰，目的是让子类实现这个方法。又不能被重写，又要求实现，矛盾

3. 接口应用场景：

1) 无法统一实现，即使实现了意义也不大

2) 软件实现流程，详细设计阶段。统一类功能，方法名，返回，参数等信息

4. 接口的特点：

1) 用 interface 来定义。

2) 接口中的所有成员变量都默认是由public static final修饰的。

3) 接口中的所有方法都默认是由public abstract修饰的。

4) 接口没有构造方法。

5) 实现接口的类必须提供接口中所有方法的具体实现内容。 

5. 抽象类VS接口

相同点：

i. 接口和抽象类都不能被实例化。只能被其他类实现和继承。

ii. 接口和抽象类都可以包含抽象方法，实现接口和抽象类的类都必须实现这些抽象方法，否则实现的类就是抽象类。

不同点：

iii. 抽象类与接口定义不同：抽象类abstract class ,接口  interface

iv. 接口里只能包含抽象方法，不包含已经实现的方法；抽象类则完全可以包含普通的方法。

v. 接口里不能定义静态方法；抽象类可以定义静态方法

vi. 接口里只能定义静态常量属性，不能定义普通属性；抽象类里既可以定义普通属性，也可以定义静态常量

vii. 接口不包含构造函数；抽象类可以包含构造函数，抽象类里的构造函数并不是用于创建对象，而是让其子类调用这些构造函数来完成属于抽象类的初始化操作。

viii. 一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java的单继承不足

 

 

 

 

 

 

Day11数组

1. 数组

什么是数组

数组是存储同一数据类型多个元素的集合,int a[],Person [] p

数组适用场景

集合，更适用于容器大小固定

不适用于对元素的增加，删除

数组一旦初始化，长度不可变

2. 一维数组声明

int a[];

int[] a1;

double  b[];

Date[]c;

3. 数组初始化

 动态初始化：数据类型[] 数组名 = new 数据类型[数组长度];

 静态初始化：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};，可以简写为：数据类型[] 数组名 ={元素1,元素2,…}

 每个数组都有一个属性 length 指明它的长度

 数组元素的引用方式：数组名[数组元素下标]

 数组元素下标可以是整型常量或整型表达式

 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 至 n-1

4. 数组的异常信息：

 ArrayIndexOutOfBoundsException

 NullPointerException

5. 数组的应用

遍历，赋值，冒泡排序，传值和传址

6. 二维数组

一维数组中每个元素又都是数组

二维数组访问，遍历，赋值

 

 

 

常用类

1. Object类

所有类的父类。Equals,toString方法默认实现。如果不满足子类需求，可以重写（多态）。

==和equals区别

 

2. String类

String不可变字符串。subString，trim，length，split

3. StringBuffer

可变字符串。字符串拼接频繁，次数较多。

Append

4. 包装类

基本数据类型，只有int和char包装类特殊。

Integer.parseInt()把字符串转换成int类型

String.valueof()把数值型转换成String类型

5. Date & DateFormat 类

Date date = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

System.out.println("使用sdf格式化："+sdf.format(date));

 

 

Day16反射

1. 反射有什么好处 应用场景

动态编译，需要什么加载什么

只要知道类名，通过反射能知道类的所有内容。在修改成员变量值时，可以和业务无关

例如：Student,知道成员变量，set方法修改成员变量的值

通过反射，只要知道类名即可知道类的相关信息，通过某种方式set值即可

2. 反射

操作类Class.forName()，数据库驱动加载

反射操作构造方法：

无参：获取类.newInstance

有参：获取构造方法 构造方法.newInstance

操作属性:获取类.getDeclaredField()

操作方法：类.getDeclaredMethod，method.invoke

Class c1 = Class.forName(“”);

  () p = c1.newInstance();

Method m1 = c1.get(“”,返回类型.class)

M1.invoke(p,chuzhi)

Sysout(0)