编程java梦想数_JAVA基础总结

JAVA基础知识点总结

一、基础部分

命名规范

变量，方法，类名要见名知意

类成员变量首字符小写，驼峰命名法

局部变量：首字母小写，驼峰命名法

类名：首字符大写，驼峰命名法

方法名：首字母小写，驼峰命名法

包名全部小写，类首字符大写

常量全部大写，用下划线分隔

常量在编译期就要确定值

三高问题：高可用，高性能，高并发

JAVA特性

简单性

面向对象

可移植性

高性能

分布式

动态性

多线程

安全性

健壮性

java运行原理

编写代码

javac java文件 -->class文件

运行class文件

编程语言运行机制

编译(compile)

c++,c,操作系统

解释

python

Java数据类型

基本数据类型

数值型

整形：byte，short,int ,long

浮点型:float,double

字符型:char

布尔型:boolean

引用类型：类，接口，数组

注意：

一般long类型的数后加L

float类型后加F

所有的字符本质为数字

2**16=65536，a=97,A=65

类型转换

低--------------------------------------------------------------------高

byte，short，char->int->long->float->double

强制类型转换：高--低

自动转换:低-----高

注意：

不能对布尔转换

不能把类型转换为不相干的类型

转换可能出现内存溢出或者精度问题

JDK7新特性，数字之间可以用下划线分割 如：100_00_00

Java是强类型语言，每个变量必须声明其类型

变量三要素：变量名，变量类型，作用域

变量作用域：

局部变量：在成员方法内部定义的变量，必须声明初始化值

实例变量(成员变量)：从属于对象，如果不自行初始化，为这个类型的默认值

布尔值默认为false

除基本类型外，其他都为null

数值型默认值为0

类变量(static)：从属于类

常量：初始化后不再改变

变量的规律：变量类型前都是修饰符，修饰符不存在先后顺序

运算符

算数运算符：+ - * / % ++ --

赋值：==

关系：> < >= <= == != instanceof

逻辑：&& || ！

位：& | ^(异或) ~(取反)<< >>>

条件：？ ：

扩展赋值：+= -= *= /=

进行算数运算时，有long的结果为long,有double的结果为double，short+byte(其他)=int

++ -- 为一元运算符(可以单独运算，区别于+、-)

幂运算：Math.pow(2,3) ==>2**3=8

逻辑与：两真为真

逻辑或：有真为真

加号两侧，一方出现String，把其他转化为String后连接

JavaDoc命令用来生成自己的Api文档

@author作者名

@version版本号

@Since知名最早使用的jdk版本

@param参数名

@return返回值

@throws异常抛出

JAVA流程控制

Jdk5新特性，scanner获取用户输入

Scanner scan=new Sanner(System.in);

凡是属于Io流的类，要即使关掉流

scan.close();

next():

必须输入值

有空格，自动去除

next不能带有空格

nextlint():

返回回车前的所有字符

21、打印99乘法表

//打印99乘法表

for (int j = 1; j <=9 ; j++) {

for (int i = 1; i <= j; i++) {

System.out.print(j + "*" + i + "=" + (j * i)+" ");

}

System.out.println();

}

break跳出循环，continue跳出本次循环

质数：大于1的自然数中，除了1和它本身以外不再有其他因数的自然数

打印101-105之间的质数

public static void main(String[] args) {

int count = 0;

outer: for (int i = 101; i < 150; i ++) {

for (int j = 2; j < i / 2; j++) {

if (i % j == 0)

continue outer;

}

System.out.print(i+ " ");

}

}

计算0-100之间的奇数和，偶数和

public static void main(String[] args) {

int oddSum = 0; //用来保存奇数的和

int evenSum = 0; //用来存放偶数的和

for(int i=0;i<=100;i++){

if(i%2!=0){

oddSum += i;

}else{

evenSum += i;

}

}

System.out.println("奇数的和："+oddSum);

System.out.println("偶数的和："+evenSum);

}

用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

public static void main(String[] args) {

for(int j = 1;j<=1000;j++){

if(j%5==0){

System.out.print(j+"\t");

}

if(j%(5*3)==0){

System.out.println();

}

}

}

重载：在同一个类中，相同函数名，参数不同

规则：方法名必须相同

参数列表必须不同(个数，类型，排列顺序)

方法返回值类型可以想通，可以不同

在同一个勒种

可变参数(...)

在参数类型后+省略号

一个方法只能指定一个可变参数，必须是方法的最后一个参数

任何普通参数必须在它之后申明

递归(自己调用自己)

递归头：什么时候不能调用自身的方法(如果没有递归头，则陷入死循环)

递归体：什么时候调用自身的方法(阶乘)

public static void main(String[] args) {

System.out.println(f(5));

}

public static int f(int n) {

if (1 == n)

return 1;

else

return n*f(n-1);

}

二、数组

数组的定义

数组是相同类型数据的有序集合

数组表述的是相同类型若干数据，按照一定先后顺序组合

每一个数据称为一个数组元素，每个数组元素可以通过下标来访问

数组的四个基本特点：

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型,不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组三大初始化：

静态初始化：int[] a=[1,2,3]

动态初始化：int[]a=new int[10]

默认：数组为引用类型，数组一经初始化分配空间，被隐式初始化

arrays.sort()：排序(升序)

三、内存分析

声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法

声明一个数组的时候并没有数组被真正的创建。

构造一个数组，必须指定长度

四、排序算法

冒泡排序算法的原理：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的

数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

class Bubble {

public int[] sort(int[] array) {

int temp = 0;

// 外层循环，它决定一共走几趟 //-1为了防止溢出

for (int i = 0; i < array.length - 1; i++) {

int flag = 0; //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环

//内层循环，它决定每趟走一次

for (int j = 0; j < array.length - i - 1; j++) {

//如果后一个大于前一个,则换位

if (array[j + 1] > array[j]) {

temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

flag = 1;

}

}

if (flag == 0) {

break;

}

}

return array;

}

public static void main(String[] args) {

Bubble bubble = new Bubble();

int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};

int[] sort = bubble.sort(array);

for (int num : sort) {

System.out.print(num + "\t");

}

}

}

选择排序算法的原理：

是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

class SelectSort{

public int[] sort(int arr[]) {

int temp = 0;

for (int i = 0; i < arr.length - 1; i++) {// 认为目前的数就是最小的, 记录最小数的下标

int minIndex = i;

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

if (arr[minIndex] > arr[j]) {// 修改最小值的下标

minIndex = j;

}

}// 当退出for就找到这次的最小值,就需要交换位置了

if (i != minIndex) {//交换当前值和找到的最小值的位置

temp = arr[i];

arr[i] = arr[minIndex];

arr[minIndex] = temp;

}

}

return arr;

}

public static void main(String[] args) {

SelectSort selectSort = new SelectSort();

int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};

int[] sort = selectSort.sort(array);

for (int num : sort) {

System.out.print(num + "\t");

}

}

}

五、面向对象

break结束方法，返回一个结果

一旦定义有参构造，必定以无参构造

1. 构造器

和类名相同

无返回值

构造器作用:

new本质为调用构造方法

初始化对象的值(alt+insert)

2.三大特性

2.1 封装

优点：

提高安全性，保护数据

隐藏代码实现细节

统一接口

可维护性增强

2.2继承(ctrl+h继承树)

调用父类构造器必须放在第一行

方法的调用只和左边的数据类型有关

2.2.1方法重写

方法名相同

参数列表相同

范围可以扩大，不能缩小

抛出异常可以缩小，不能扩大

2.3多态

多态特征

多态是方法的多态，属性没有多态

父类子类有联系

存在继承关系，方法要重写

父类引用指向子类

不可重写的情况

static属于类，不属于实例，静态方法不可重写

final修饰不可重写

private修饰不可重写

tips:

父类引用指向子类，不能调用子类独有的方法(对象能执行哪些方法，主要看左边的类型)

多态的条件

有继承关系

子类重写父类的方法

父类引用指向子类的对象

instanceof判断两个类是否存在父子关系

补充

父类引用指向子类对象

把子类转为父类，向上转型

父--子，向下转型(强制类型转换)

方便方法调用，减少重复代码

六、static关键字

非静态可访问静态方法

静态方法只能调用静态方法，不可以调用普通方法

代码块，静态代码块执行顺序

静态代码块

匿名代码块

构造方法

七、抽象类

抽象方法，只写方法名，不用实现

抽象类所有的方法,继承了它的子类必须实现它的方法

如果子类是抽象类，name交给子子类

注意

抽象类不能new,只能靠子类实现

抽象方法必须在抽象类中

抽象类可以写普通的方法

八、接口

定义：只有规范，约束和实现分离，面向接口编程

接口中所有的定义默认是抽象的

可实现多个接口，用 “ ，” 隔开

注意：

约束

定义方法，让不同的人实现

接口不能被实例化