Java知识点

Java知识点

第一章 准备工作

1-1 jdk的安装

下载安装包–>选择安装路径–>配置环境变量–>检验安装是否成功

*重点 *

1. 安装完jdk之后，会提示安装jre，注意最好不要将两者放在同一个目录下

2. 配置环境变量(JAVA_NAME和Path)

   JAVA_HOME	Java的安装路径
   Path	%%JAVA_HOME%\bin

3. 在DOS中输入javac以及java -version \注意空格

4. 常见的dos命令

   常见的dos命令
   md	make directory	创建目录
   rd	remove directory	删除目录
   cd	come directory	进入目录
   cd…		退回上级目录
   cd\		退回根目录
   del	delect	删除文件

1-2 HelloWorld程序

public class HelloWorld{

public static void main(String[] args){

System.out.print("Hello World");

}

}

创建一个HelloWorld.txt文档–>在notepad++中打开并写下上述代码–>命令行编译

要点：1.公共类名要和文件名保持一致；2.注意大小写；3.无空格

1-3 Java IDE的使用

eclipse的使用

如何添加新版本的jre

​ Windows–>Preferences–>Generals–>installed JREs–>Add

​ -->standard VM–>在jre home中填入jdk安装路径–>勾选

如何新建Java project

1. 通过快捷栏
2. File–>project–>java project -->输入项目名–>输入包名（公司域名反写）–>添加类

如何修改方法名

1. 在方法上鼠标右键–>Refactor–>Rename
2. 快捷键shift+alt+r

如何显示package树

​ Window–>show view–>package

快捷键

CTRL+shift+F 格式化

alt+shift+r 修改方法名

alt+shift+x,j 运行

alt+/ 快捷输入的

第二章 Java基础知识

2-1 认识Java程序

理解main( )为何物

1. java程序的入口就是main( )方法
2. main( )方法必须是 public static void类型的，方法必须接收一个字符串数组类型的

static 的意思

static 指的是静态的，静态的方法意思是该方法不需要实例化就可以使用。

String args[ ] 的作用

1. 作为main方法的参数

注释

1. 单行注释

   //单行注释
   

2. 多行注释

   /*多行注释*/

3. Java doc注释

/**
*doc注释
*
*/

2-2 变量和常量

变量的声明

​ Java中，变量必须声明，否则报错

​ eclipse中，局部变量不初始化不会报错，但是使用的话就会报错；

​ 类变量不初始化Java会自动初始化，可以直接使用。

变量的范围

1. 定义：变量的的范围从变量定义开始，到大括号结束。在此范围之外，从任何地方访问变量都会造成错误
2. 在Java中变量的作用范围内不能重复定义，但是在作用域外可以

常量

1. 定义方法： public static final 类型 常量名=常量值

2-3 数据类型

Java数据类型可分为两类：基本类型和引用类型

一、八种基本类型

类型	名称	字节空间	说明	取值范围
byte	字节	1	储存一个字节数据	-128~127
short	短整型	2	用的很少
long	长整型	4	储存整数
float	单精浮点型	4	储存小数
double	双精浮点型	8	储存小数
char	字符型	2	储存一个字符
boolean	布尔型	1	储存逻辑变量

占据字节空间小的可以向大的类型转换

二、引用类型

1. 引用类型指向的是一个对象，而不是一个值
2. 引用类型可分为：类、接口、数组

2-4 标识符

Java中标识符即：类名、方法名、变量名、包名

Java中，标识符由五种符号组成：字母、数字、下划线、￥、$

为了增强程序的可读性，Java做出以下约定

1. 包名：全部小写（公司域名反写）
2. 类、接口：通常使用名词，每个单词的首字母大写
3. 方法：首字母小写，随后用大写字母分隔每个单词
4. 常量：全部大写，单词之间用下划线分隔
5. 变量：通常使用名词，首字母小写，随后使用大写字母分隔每个单词，避免使用$字符

变量的标识符规则：

1. 变量只能以四种符号表示：字母、数字、下划线、$
2. 变量不能 以数字开头
3. 变量名不能与关键字冲突
4. 变量名尽量有意义

Java关键字

java关键字
case	catch	char	class	continue
default	do	double	else	enum
extends	final	finally	float	for
if	implements	import	instanceof	int
interface	long	public	new	package
private	protected	native	return	strictfp
short	static	super	switch	synchronized
this	throw	throws	trancient	try
void	volatile	while	break	byte
abstract	Assert	boolean

转义字符

转义字符	说明
\n	回车
\t	tab
\b	space
\r	换行
\f	换页
\’	单引号
\"	双引号
\\	反斜杠
\ddd	三位八进制
\udddd	四位十六进制

注意转义字符的斜杠是反除号

算术运算符

加减乘除，取余，自增自减。

赋值运算符

运算符	用法	等效表达式
+=	a+=b	a=a+b
-=	a-=b	a=a-b
*=	a*=b	a=a*b
/=	a/=b	a=a/b
%=	a%=b	a=a%b
&=	a&=b	a=a&b
|=	a|=b	a=a|b
^=	a^=b	a=a^b
>>=	a>>=b	a=a>>b
>>>=	a>>>=b	a=a>>>b

关系运算符

基本与C一致

区别在于，Java中关系运算结果返回值为Boolean型值false或true, 在C或C++中，返回值是0或1

逻辑运算符

&& 二元运算符 短路逻辑与

|| 二元运算符 短路逻辑或

& 二元运算符 非短路逻辑与

| 二元运算符 非短路逻辑或

！ 二元运算符 非、取反

短路逻辑

在&&（与）和 || （或）这两个双元短路逻辑运算符的运算中，若已经判断前一个元的真假，后一个元的运算就不必运算，这种情况称之为短路

非短路逻辑

无论如何都执行后一个元

用&和 | 表示

说明

1. 短路逻辑运算符的运算效率高
2. 逻辑运算符通常和if表达式结合使用

位运算符

位运算符是针对二进制进行操作的，了解即可

其他运算符

1. Java实例运算符instanceof

2. Java内存分配运算符new

3. 三目运算符

   布尔表达式？值1：值2

   该表达式意思是：如果该布尔表达式的结果为true，则输出1，为false，则输出2.

运算符号的优先级

不用刻意去记，用小括号代替更直观

2-5 程序流程控制

顺序结构

选择结构

选择结构大致有三种：if 语句、if……else if 语句、switch语句

if语句

if

1. if（布尔表达式）{……}
2. if语句不加括号时可以控制紧接的一行代码

if……else if

1. if（布尔表达式1）{……}

   else if{……}

   else if{……}

   ……

   else{……}

2. else，else if 可以省略

switch

1. switch（整型或字符型变量）{

   case 值1：语句1；break；

   case 值2：语句2；break；

   case 值n：语句3；break；

   default： \\注意这里是冒号

   }

循环结构

1. while循环

   while（执行循环的条件的布尔条件式）{循环内容}

   在while循环中，可以将执行循环的布尔条件式直接写为true,这样可以无限死循环。

2. do……while循环

   do {

   …

   } while（条件式）；

3. for循环

   for（初值；终止条件；增、减量）{

   程序语句

   }

   可以用双循环打印九九乘法表

   for(i=1;i<=9;i++){

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

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

   }

   System.out.println();

   }

4. 增强for 循环

   for(定义变量：遍历数组){ }

   注意定义变量不是后面遍历的数组名，而是一个新的变量，并且数据类型要和所要遍历的数组的类型相同

5. break和continue语句

   break语句

   break语句有三种作用

   1. 在switch语句中终止一个语句序列

   2. 在用来退出一个循环

   3. 与标记语法结合，作为一种先进的goto语句来使用

   例如：如下的双循环

    out：for(;;){
   	语句……
   	in：for(;;){
   	语句……
      	if（布尔值语句）{ break out ; }
   	}
   }
   

   continue 语句

   ​ 作用：提前结束此次循环

2-6 数组

数组的遍历

1. 普通for循环
2. 增强for循环

数组的默认值

int 类型数组每个元素的默认值时?0

String类型数组每个元素的默认值是?null

char类型数组每个元素的默认值是？空

double类型数组每个元素的默认值是0.0

float类型数组每个元素的默认值是?0.0

其他对象类型每个数组元素的默认值是?null

数组的操作

数组的扩充方式

1. 扩容方式1—赋值法

   即定义一个新的较大容量的数组，再将小容量的数组中的元素赋值给大容量数组

   int[] team1 = new int[] {1,2,3} ;
   int[] team2 = new int[team1.length*2];
   for(int i = 0; i<team1.length;i++){
       team2[i]=team1[i];
   }

2. 扩容方式2—java.utli.Arrays.copyOf(原数组名，新数组长度)；

int[] team1 = new int[] {1,2,3};
int[] team2 = java.util.Arrays.copyOf(team1,team1.length *2);

此方法通过java.unit.Array.copyOf创建新数组同时扩容

3. 扩容方式3—System.arraycopy(原数组名，起始下标，新数组名，复制长度)

   int[] team1 = new int[]{1,2,3};
   int[] team2 = new int[team1.length *2];
   System.arraycopy(team1,0，team2,0,team1.length);

此方法通过先创建新数组，再用System.arraycopy复制数组的方式，

Array类

简介

java.util.Arrays是操作数组的工具类，它能方便的操作数组，提供的所有方法都是静态的

功能：

1. 给数组赋初值：通过fill方法。
2. 对数组排序：通过sort方法，按升序。
3. 比较数组：通过equals方法比较数组中元素是否相等。
4. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找。

一维数组

一维数组的声明

1. 先声明，再初始化

   int [ ] a;	或  int a[ ];		\声明
   a=new int [ ]{ 1,2,3}；		\\初始化

2. 声明，直接初始化

   int [ ] a={1,2,3};

3. 声明，再初始化的第二种语法

   int [ ] a=new int[ ]{1,2,3};

4. 声明给出大小

   int [ ] a=new int [ 2];

数组的下标

注意数组下标均从0开始

数组的长度

a.length 表示数组a的长度

数组的打印

1. 使用for循环打印

   int [ ] a= {1,2,3};
   for(int i=1;i<=a.length;i++)
   System.out.println(a[i]);

2. 使用Arrays打印

   使用Arrays打印需要导入java.util包

二维数组

1. 数组的声明
2. 二维数组里存放的是一维是数组
3. 二维数组的下标

多维数组

综合实例

2-7 方法

2-7.1 基本知识

1. 方法定义： 修饰符 返回值类型 方法名（参数）{ }

   1. 修饰符：可选的，告诉编译器如何调用该方法，定义了该方法的访问类型
   2. 返回值类型：方法可能有返回值
   3. 函数名：函数名的书写遵循驼峰原则，首字母小写，之后的每个单词首字母大写
   4. 参数：此处是形参，参数可以有多个，也可以没有，作用作为向该方法传递值的媒介
   5. 方法名与方法参数数目和类型构成方法的签名

2. 方法的返回值

   1. 有返回值时注意定义方法时指定返回值类型，比如boolean型、int型等。
   2. 无返回值应指定void型。

3. 方法的参数

   1. Java的参数分为普通参数和可变参数

      1. 普通参数

         形参几个，实参也得几个

      2. 可变参数

         定义：类型… 参数名称

         注意：可变参数的形参是数组

         举例：

         public void run ( int...  params ){  
         
         for(int value:params)
         
         System.out.println(value[i]);
         
          }

4. 方法的重载

   方法重载是指在同一个类中，定义多个方法名相同，但参数类型和参数数目不同的方法

2-7.2 方法的调用

1. 方法中的形参和实参

2. 方法中值参数传递方式

   1. 按值传递

      参数类型是八种基本数据类型是，参数传递采用值拷贝的方式，即形参将实参的值copy一份到形参的方法栈帧

   2. 引用传递

      方法中传递类：

      public void addSalary(Addorder param){

      }

2-8 这些算法很有用

2-8.1 比较值

最值

略

平均值

略

2-8.2 数字排序

冒泡排序

原理：

设数组 a= { 6，4，3，2，1} ，将相邻两个值进行比较，大的放右边，按照从左向右的顺序遍历数组中的值。

实现：

第一次循环结果：{ 4，3，2，1，6} \经过四次比较，最大值6“冒出”

第二次循环结果：{ 3，2，1，4} \经过三次比较，最大值4“冒出”

……

第四次循环结果：{ 1，2 } \经过一次比较，最大值2“冒出”

比较，是内层循环做的事；循环，是外层循环做的事。

以上是最坏的情况，程序需要执行四次外层循环，需要执行4+3+2+1次内层循环，扩展到n个数据时，需要执行n-1此外层循环

，(n-1)n/2次内层循环.

package com.star;

public class BubbleSort {

	public static void main(String[] args) {
		int[] test = new int[] {2,34,12,35,56,23,2345,454,13,234};
		int max;
		for (int before : test) {
			System.out.print(before+" ");
		}
		//外层循环
		for(int i=0;i<test.length-1;i++) {
		/*
		注意此处为什么是j<test.length-1-i,虽然循环的趟数是数组长度减一，其中也是小于号，但是j是从0开始的，所以j=0也是一趟，很容易忽视
		
    */
			for (int j = 0; j <test.length-1-i; j++) {
				if (test[j]>test[j+1]) {
					max=test[j];
					test[j]=test[j+1];
					test[j+1]=max;
				}
					
				}	
		}
		System.out.println("\n");
		for (int after : test) {
			System.out.print(after+" ");
		}
	}

}

选择排序

原理 ：

设数组a={ 5，4，3，2，1 } ，将后四位数分别与第一位数进行比较，如果比第一位小，则将两位数字换位。

实现：

第一次外循环结果：{ 1，5，4，3，2}

第二次外循环结果：{ 2，5，4，3}

……

第四次外循环结果：{ 4，5 }

以上是最坏的情况，内外循环次数和冒泡法相同

2-8.3 查找

2-8.4 Java工具类中算法的实现

对于2-8.1~2-8.3这些算法在Java中都提供了相应的API供用户调用

在Java的java.util包下有一个类Arrays

1. 如何调用

   //导入java.util下的包的类
   import java.util.Arrays
   ······
   //调用相应的API
   Arrays.方法名（）

2. 内含的方法

   1. 使用工具类打印数组

      //使用toString方法打印数组
      import java.util.Arrays;
      public class A{
          public static void main(String args){
          int[] a={1,2,3,4};
          System.out.println(Arrays.toString(a));
      
          }
      }

   2. 使用工具类排序

      //使用toString方法排序数组
      import java.util.Arrays;
      public class A{
          public static void main(String args){
          int[] a={5,2,3,4};
              Arrays.sort(a);
          System.out.println(Arrays.toString(a));
      	}
      }

   3. 使用工具类二分查找

      //使用二分查找返回目标元素在排序之后的数组中的下标
      import java.util.Arrays;
      public class A{
          public static void main(String args){
          int[] a={5,2,3,4};
              Arrays.sort(a);  //一定记住要先排序再写下标
              int B = Arrays.binarySearch(A,3);
          System.out.println("下标在："+B+"位置");
      	}
      }

3. Random工具类可以生成随机数

   //使用二分查找返回目标元素在排序之后的数组中的下标
   import java.util.Random;
   public class A{
       public static void main(String[] args){
           //随机生成0~10000的数不包括10000
   	Random ran = new Random();
       int a = ran.nextInt(10000);
       System.out.println("随机数是"+a);
   	}
   }

2-9 Java的对象、类

2-9.1 类的定义和组成

1. 类的定义00

   【访问权限修饰符】 【修饰符】 class 类名 { 类体 }

2. 类的组成

   1. 成员变量
   2. 方法
   3. 构造方法
   4. 初始化块
   5. 内部类

   /**
   *
   *
   */
   public class User{
       /**用户ID*/
       String id;	//实例变量（实例化之后才能访问的变量）
       
       /**手机号*/
       private String mobile;	//实例变量
       
       /**用户名*/
       private String userName;	//实例变量
       
       /**所在部门*/
       private static String department;	//类变量
       
       /**学历*/
       final String degree;	//常量
       
   }

2-9.2 对象的创建

创建步骤：

1. 声明：声明一个对象，包括对象名和对象类型

2. 实例化：使用关键字new来创建一个对象

3. 初始化：使用new创建对象时，会调用构造方法初始化对象，给对象赋初值

2-9.3 构造方法及其重载

1. 定义

   Java中一种特殊的方法，方法名和类名相同，可以有参数，但无返回值。

   说明：

   每个类都有构造方法，如果没有显式的为类定义构造方法，那么Java编译器回为该类提供一个构造方法

   但是如果类中定义了构造方法，那么Java将不再提供默认的构造方法

   构造方法需要

2. 作用

   • 创建对象

     创建一个对象必须调用构造函数

   • 对象初始化

3. 构造方法与普通方法的区别

   • 格式不同

   • 调用时期不同

     构造方法在对象创建时就调用，普通函数在对象执行是才调用

   • 调用次数不同

     构造方法在程序执行过程中只执行一次，普通函数可以执行多次

4. 构造方法的重载

public class text{
    public text(int param){}
    public text(){}
    
}

2-9.4 this关键字

1. this的作用
   • this可以看作是一个变量，它的值是当前对象的引用，简单可以理解为对象的指针
   • 方法中使用this关键字表示
   • this关键字可以解决方法中成员变量名和方法中参数名重复的问题
2. this的总结
   • this一般出现在方法里面，方法没有调用时，this指哪个对象并不知道
   • 如果new了一个对象，那么this就指向该对象
   • 如果再new一个对象，那么this就指向该对象
3. 应用

public class text{
    public text method1(){
        System.out.println("100");
        return this;
    }
    public void method2(){
        System.out.println("200");
    }
    public static void main(String[] args){
     text eg = new text ();
     text.method1.method1.method2;   
    }
}

注意倒数第三行，text.method1.method1.method2; 由于method1返回值是当前的对象text，所以(text.method1)==text，因此，后面的（···）.method1相当于还是相当于text.method，以此类推，后面的表示text.method。

2-10 面向对象的特性

Java语言的特性：面向对象，封装，继承，多态

封装（Encapsulation）

属性可用来描述同一类事物的特征，方法可描述一类事物可做的操作，封装就是把属于同一类事物的共性（包括方法与属性）归到一个类中，以方便使用

1. 概念

   封装也成为信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起

2. 优点

   • 实现了专业的分工

   • 隐藏数据

     比如银行密码，程序员无法访问，用户可以访问

继承（inheritance）

继承的概念

继承就是对共性的属性与方法的接受，并加入个性特有的属性与方法

• 概念

  一个类继承另一个类，则称继承的类为子类，被继承的类为父类。

• 目的

  实现代码的复用

• 理解

  子类与父类的关系并不是日常生活中的父子关系，Java语言中是is-a 的关系。子类是父类更加详细的分类。设计继承的时候若要让子类能继承，父类需要开放访问权限，遵循里氏替换原则，即对修改关闭对扩展开放，也就是开-闭原则

• 结果

  继承后的子类拥有了父类的属性和方法，但特别注意的是，父类的私有属性和构造方法并不能被继承

  另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法，即方法的重写。

extends关键字

见代码

继承类型

1. 单继承

   public class A({……}

   public class B extends A{……}

2. 多重继承

   public class A{……}

   public class B extends A{……}

   public class C extends B{……}

3. 多继承 //Java中extends语句不支持此种继承方式

   public class A{……}

   public class B{……}

   public class C extends A,B{……}

4. 不同类继承同一个类

访问修饰符

• public：
• protected：重点突出继承，继承，同包都能访问,
• default：重点突出包，同包都能访问
• private：

访问级别	访问控制修饰符	同类	同包不同类（不含子类）	同包子类	不同包不同类（不含子类）	不同包子类
公开	public	√	√	√	√	√
受保护	protected	√	√	√	\	√（注意）
默认	不加关键字	√	√	√	\	\
私有	private	√	\	\	\	\

注：子类即类的继承后子类

使用super关键字调用父类的属性和方法

super是指向父类对象的指针

• 指向父类的引用

• 子类的成员变量和父类的成员变量重名时加以区分

• 引用构造函数

多态（Polymorphism）

2-11 修饰符

2-11.1 final修饰符

final表示最终的、最后的，意味着不可修改

final修饰变量

• final变量一旦被赋值就不能再被赋值
• 被final修饰的实例变量必须显式指定其初始值(可以在声明的时候直接初始化，先声明，在代码块、构造函数中初始化)
• final修饰符经常和static修饰符一起使用创建类变量

final 修饰方法

类中的final的方法可以被子类继承，但不能被子类修改，即子类不能重写

声明final方法的主要目的是防止该方法的内容被修改

final修饰类

final修饰的类不能被继承

2-11.2 static修饰符

用来修饰类方法和类变量

1. 静态变量（静态属性、类变量）

   static关键字用来声明独立于对象的变量（即访问此变量的时候，如果在当前类内，直接通过变量名访问，如果在不同类中访问，用类名.变量名即可），无论一个类实例化多少对象，它的静态变量只有一份拷贝

   局部变量不能被声明为static类型

2. 静态方法

   static关键字用来声明独立于对象的方法

   静态方法不能直接使用类的非静态变量（实例变量必须创建实例才能被静态方法使用，比如main函数就是一个静态方法，public class中的实例变量必须创建public class的对象之后，在静态的main方法中才能调用)

3. 编写静态代码块

   代码块就是用大括号括起来的一段代码

   静态代码块就是在代码块前面加上static关键字

   静态代码块是用来初始化的（构造函数也是拥有同样的功能）

   静态代码块只能用来初始化静态变量，实例变量（非静态变量是不能在静态代码块里边面初始化的）

   实例化的时候会运行静态代码块中的语句

4. 变量初始化的顺序

   构造函数–>代码块–>实例变量–>静态代码块–>静态变量

2-11.3 abstract 修饰符

抽象方法（目前不需要写方法体的方法，声明为抽象方法）

抽象方法是一种没有任何实现的方法，该方法的实现具体由子类提供

• 抽象类不能被声明为static、final
• 抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类
• 如果一个类包含一个或多个（若干个）抽象方法，则该类必须声明为抽象类，抽象类可以没有抽象方法
• 抽象方法不能直接实例化，只能通过方法的重写才能实例化

2-12 接口

2-12.1 接口的概念

1.接口的定义语法

2.接口的理解

3.接口与类的区别

4.接口与抽象类的区别

5.接口的多继承

2-12.2 接口的实现