1、编程语言的划分：

面向对象：强调的是拥有这个方法的对象，比如：找到卖鸡蛋灌饼的大妈，给钱，吃。事物简单化、更符合人的逻辑思维，执行者-指挥者，java c++

面向过程：强调的是过程，比如：买鸡蛋，和面加鸡蛋，找锅，查找教程，做，吃。C

2、java语言版本的分类：

标准版：javase

小型版：javame

企业版：javaee(主要针对的是web语言)

3、java语言的特点：

简单的

面向对象的

分布式的(每一个方法对应一个功能模块)

安全的(核心代码加密)

多线程的(比如：1号窗口买票了，其他窗口同步更新票据)

开源的：开源并不等于开放源代码，真正的开源还包括开源社区和接收开源代码，比如开源软件：linux,mysql,tomcat,firefox;闭源：windows,苹果系统

跨平台的(linux/windows)：通过java编写的应用程序在不同的系统平台上都可以运行。原理：运行java的操作系统上，先安装一个JVM(java虚拟机)即可，由JVM来负责java在该系统中的运行。

4、环境的配置：

JRE:java运行环境(java runtime environment)，包含java虚拟机和java核心类库。

JDK：java开发工具包(java development kit)，java的开发工具，包含了JRE.

5、java项目的编译过程：

java文件-->编译工具javac.exe-->生成一个字节码文件（.class）-->运行工具（java.exe）

比如：hw.java->javac.exe->hw.class->java.exe->产生结果

bin目录里面有字节码文件

6、命名规则：

项目名称、类命名：不能出现中文、只有一个单词，字母首字母大写；多个单词，每个单词的首字母都要大写。XxxYyyZzz

方法名：第一个单词小写，其余单词每个单词首字母大写。xxxYyyZzz

包名：一律小写规则：公司域名倒写+项目名字+项目模块的名字

7、Java文件的构成：

由一个一个类组合而成。一个java项目，可以包含多个java文件（类文件），每一个java文件都是由类去组成的（可以有多个类），每一个类可以有多个方法。

Java项目--java文件--类--方法

基本组成单元是类，类中有属性与方法两部分，对象是类的一个具体实例。

类是对现实生活中一类具有共同特征的事物的抽象。含有main方法的称为主类。

8、基本术语

类：属性（变量）+方法（函数）

全局变量：类中、方法外

局部变量：出现在方法中

常量：字面值常量（写什么就是什么）+自定义常量（面向对象部分），整数常量、小数常量、字符常量‘a’‘A’、布尔常量、字符串常量“a”“A”、空常量null

比如：final double PI = 3.1415926声明常量一定要赋值

9、类型转换

自动类型转换：隐式转换，小类型转大类型小范围转大范围，int-long,double不能到float

Byte-short-int-long-float-double

Char-int-long-float-double

char在一定条件下可以和byte相互转换

强制类型转换：显示转换

10、转义字符：

一种特殊的字符变量。

11、标识符：

字母、数字、下划线、美元符（第一个不能是数字、不能使用关键字）

12、程序的流程控制：

结构化设计角度来看，顺序结构、选择结构、循环结构

13、Scanner类：

首先，根据scanner类生成相应的对象；根据对象来调用输入的方法

Scanner sc = new Scanner(System.in);

Int a = sc.newInt();

一定要导包：import包名;

Println()自带换行功能，print()不带换行功能

^异或：双方不同则为真

14、break和continue

Break:整个程序终止；

Continue:跳转到程序开始的地方

15、循环语句：

switch……case：case表达式的值必须是整型、字符型、字符串型，case的常量值也必须互不相同。

While和do While:while里面一定要有参数的变化，否则死循环；dowhile至少执行一次

For循环：for(初始化语句，循环判断语句，循环变化语句){循环体}

16、数组：

数组可以看成一个对象，相同数据类型的元素集合。每一个数据都叫做元素。

先声明、后指定长度：

int arr[];arr = new int[5];

String str[];str=new String[10];

声明的同时，为数组分配内存：

int month[] = new int[12];

数据下标越界异常：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 at example.Month.main(Month.java:9)

二维数组的遍历：

for(int i =0;i<arr.length;i++) {

for(int j =0;j<arr[i].length;j++) {

System.out.print(arr[i][j]);

}

System.out.println();

}

Arrays类静态方法：

1、Sort()：升序排列，Arrays.sort(object);object指进行排序的数组名称，导包：import java.util.Arrays;

2、CopyOf(arr,int newlength):复制数组到指定长度

大于，用0填充；小于，截取

3、copyOfRange(arr,int formIndex,int toIndex):将数组的指定长度复制到一个新数组中

17、对象：

静态部分（属性即变量）

动态部分（方法即函数）

对象是类的实例化，类是对象抽象而成；类是封装对象的属性、方法的载体，具有相同属性和方法的一类事物统称为类。

比如：大雁南飞，属性：颜色翅膀体重名字，方法：飞

18、权限修饰符：

Public:所有类都能访问，一个java文件中，public修饰的类只有一次

Protected:子类、同一包的类都可以访问

默认的：同一包类公开

Private:只有类本身

Abstract：修饰类和成员

19、面向对象思想：

面向对象三大特点：继承、封装、多态。

封装：是核心思想,封装的思想是：用private将对象的属性和方法封装起来，载体是类，类通常对客户隐藏其实际细节。优点：保护了类内部的完整性，避免了外部操作对内部数据的影响，提高了程序的可维护性。

继承思想：新建的类从已有的类那里得到已有的特征。优点：缩短开发时间，复用已经定义好的类，提高系统的性能，减少错误几率。

多态：同样的动作不同环境下产生不同的反应

20、setter和getter方法

提供了私有化成员的对外操作，通过setter和getter来对外开放。

setter:

public void set属性名(){

this.属性名=属性名；

}

this关键字：将参数值赋予类中的成员变量。

getter:

public数据类型get属性名(){

return属性名;

}

21、构造方法：

public类名(){}

public类名(数据类型 值){}

构造方法没有返回值，并且名称与类名相同。

作用：一般就是对属性进行赋值或初始化。

默认情况下，一个类有一个无参的构造方法，一旦写了有参的构造方法，就会把无参的给覆盖掉，需要我们自己动手去声明无参的构造方法。

23、封装的顺序：

属性+构造方法+setget方法+自定义方法  StudentTest.java

24、构造方法和普通方法的区别：

1、方法名：构造方法类名，普通方法随便

2、返回值：构造方法没有返回值，普通方法随便

3、方法调用：构造方法自己不能调用，只能在创建对象时由java虚拟机来调用，普通方法方法名即可

4、方法体：构造方法可以写任何，但一般用来给属性赋值，普通方法写任何

5、构造方法：不写系统给默认的无参，写了不管写了什么系统就不给了，覆盖掉了

25、继承（记的东西较多）

定义：子类继承父类的特征和行为，使子类具有父类的各种属性和方法。

格式：Class子类名extends父类名{}（逻辑：实例化对象了之后，可以直接调用父类的属性和方法）

应用：当两个类具有相同的特征和行为时，可以抽取其中的一部分到父类，其他两个类继承这个父类。所有类都直接或间接的继承了java.lang.Object（祖先），一个类如果没有extends那么他就继承Object类。

特点：1、java只支持单继承,一个类只能有一个父类不可以有多个父类2、java支持多层继承A-B-C

注意事项：1、继承说明，子类继承父类所有成员，但父类的的私有成员以为权限问题，不能被访问；构造方法不能被继承，但子类可以通过super()去访问父类的构造方法。2、继承原则，java不允许选择继承，不能为了部分功能而去继承；继承之间体现的是“is a”的关系，即一个子类只能继承一个父类。

继承中的成员：1、java支持子父类定义相同的成员2、当使用对象的成员时遵循就近原则，先在子类找，然后父类找，没有则报错3、当成员相同，但需要使用父类成员，则需要super关键字来标明。

public void show() {

System.out.println(super.name);

}

注意：子类继承父类所有成员，私有成员不能被访问，构造方法不能被继承，但可以通过super()来访问。

super关键字：子类有参无参构造方法对于父类的引用。

1、只能在子类方法里面中使用

2、Super()调用父类构造方法时，只能在子类的构造函数中使用，且必须是子类构造函数的第一行。

3、this()和super()不能同时出现。

26、多态

定义：某一个事物在不同时刻表现出来的不同的状态。

前提：1、有继承关系2、有方法的重写（多态的意义）3、父类的引用指向子类的对象（多态的核心）

Cat cat = new Cat(); Animal a = new Cat();//父类的引用指向子类的对象

方法重写：父类中的方法子类重写1、除了权限修饰符和方法体可以不一样，其他的部分需要和父类保持一致2、子类的权限必须大于等于父类的权限

27、抽象

abstract可以修饰类也可以修饰方法。

抽象类：

格式：abstract  class  类名{}

特点：1、抽象类不能实例化（不能new），但是有构造方法。2、继承抽象类的子类必须重写抽象类中的所有的抽象方法，除非子类也是抽象的。

抽象方法：

普通方法上加上abstract   public sbstract void fangfa(){}

特点：1、抽象方法不能有方法体2、抽象方法必须在抽象类中3、子类必须重写所有的抽象方法，除非子类也是抽象的

抽象类中的成员方法：

成员变量：成员变量、常量都可以有

成员方法：可以有成员方法，也可以有抽象方法

构造方法：有构造方法，但是不能实例化

也就是抽象类里面除了有抽象方法还可以有常量、变量，还可以有普通的方法、构造方法，反过来抽象方法只能在抽象类中。

28、接口

定义：比抽象类更加抽象的类结构。

格式：interface接口名{}   class子类implements接口{} //即子类实现了这个接口

注意：1、接口可以多实现。2、实现接口必须重写接口中所有的方法3、接口中的方法默认访问修饰符是public abstract4、接口中的常量默认访问修饰符是public static final

某个类实现了某个接口，当一个类有继承又有接口要先继承后实现 class b extends d implements c,d{}法。

抽象类和接口的区别：

成员变量：抽象类可以有变量也可以有常量，接口只能有常量

成员方法：抽象类可以有成员方法也可以有抽象方法，接口只能有抽象方法

构造方法：抽象类有构造函数但不能创建对象,接口根本就没有构造函数

设计原则：抽象类和类之间是继承关系强调继承，接口和类之间是实现关系，强调拥有或包含。

29、static关键字：（静态）

Static关键字可以修饰属性和方法（即成员），修饰成员时类的所有对象都共享该成员，可以使用“类名.成员”来访问。

特点：1、静态方法不能调用非静态成员，但是非静态方法可以调用静态成员2、静态方法里面不能使用this关键字3、局部变量不能是静态的。

两种调用的方法：

1. 先实例化然后调用

在一个类里面声明属性和方法。static int num=6; public static void show(){}，再另一个主类里面实例化tests s=new tests();可以输出s.num,也可以直接调用s.show();

2.直接调用TestS.num;TestS.show();

static优点：1、修饰属性时，类的所有对象公用这一个属性，节省了内存空间2、访问很方便，不需要在创建对象了

缺点：声明周期太长（一直占用一个空间，直到程序结束才会释放），访问有限制（内存溢出，数据错乱）

代码块：

局部代码块：方法中，限制变量的使用范围。

构造代码块：类中、方法之外，执行任何构造方法之前，都必须先执行构造代码块。(实例化几次，执行几次)

静态代码块：类中、方法之外，只在类加载的时候执行一次，而且仅仅一次(实例化多次，也只执行一次)

30、String类：（字符串、也是一个声明好的类）

在java.lang包里,java使用String类创建一个字符串变量，字符串变量属于对象,java把String类声明为final类，不能被继承（重点）,String类对象创建之后不能修改，由0或多个字符组成，包含在一堆双引号之间.字符串声明：String str=“hello”;或者String str=new String();

31、字符串函数

1.获取字符串长度：str.length()  空格也算一个字符

String a ="we are";

int size = a.length();

System.out.println(size);

2、用toCharArray()来转换为一个字符数组

String b = "hello world";

char[] c =b.toCharArray();

for(int i = 0;i < c.length;i ++) {

System.out.println(c[i]);

}

3、indexOf(String s)返回字符首次出现的索引位置，找不到返回-1

String d = "we are students";

int e = d.indexOf("a");

System.out.println(e);

4.lastIndexOf(String s)最后一次出现字符的索引位置返回，没有查找到返回-1

Strin***e are students";

int g = f.lastIndexOf("s");

System.out.println(g);

注意：若参数中是空字符””，则返回的结果与调用该字符串length（）方法的返回结果相同

5. charAt()将指定索引处的字符返回

Str.charAt(int index);str:任意的字符串，index:整型值，用于指定要返回字符的下标

6.substring(int beginIndex) 从指定的索引位置开始截取直到该字符串结尾的子串，空格也占一个索引位置

substring(int beginIndex，endIndex)比如str.substring(0,3)    范围[,)

7.trim()去除空格，去掉前导空格和尾部空格str.trim().length()

8.replace(oldchar,newchar) 字符串替换  str.replace("are","is")

9.字符串大小写转换toLowerCase()转小写   toUpperCase()转大写

32、包机制

为了更好的组织类，java提供了包机制，用于区分类名的命名空间

包的作用：1、方便类的查找和使用2、避免名字（类名）冲突3、拥有包访问权限的类才能访问某个包中的类

注意事项：1、包名字母一般小写2、包的命名规则3、package语句必须是程序代码中的第一行可执行代码4、package语句最多只有一行

33、final关键字

设计类的时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被拓展，那么就设计为final类。

final:修饰类、方法、变量， 最终的意思，不能被改变了

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

2.final修饰的方法不能被子类重写

3.final修饰的变量是常量，初始化后不能被修改（final修饰全局变量，必须初始化赋值，或者在构造方法中赋值，声明和赋值可以分开来写）

final int i=13;

Final int j;

public TestF(){

this.j=9;

}