JavaSE

最新推荐文章于 2024-08-31 10:44:02 发布

Geneartion_Z

最新推荐文章于 2024-08-31 10:44:02 发布

阅读量336

点赞数

文章标签： java

本文链接：https://blog.csdn.net/geneartion_z/article/details/106178309

版权

关键字

class、extends、 implements、interface、 import、 package、 break、 case、 continue、 default、 do、 if、 else、 for、 return、 switch、 while、 false、 true、 null、 boolean、 byte、 char、 short、 int、 long、 float、 double、try、 catch、 throw、 throws、 finally、 abstract、 final、 native、 private、 protected、 public、 static、synchronized、 transient、 volatile、 instanceof、 new、 super、 void、 assert、 enum、 goto、 const

字符编码

ASCII码
‘a’ >>>>> 97[0110 0001] //解码
‘b’ <<<<< 98 [0100 0010] //编码

‘A’ >>>>> 65[0100 0001]
‘B’ >>>>> 66

‘0’ >>>>> 48[0011 0000]
‘1’ >>>>> 49

***简体中文的编码方式：
GB2312<GBK<GB18030

***繁体中文：大五码

***统一全球所有文字，容量较大【Unicode】
——UTF-8（统一编码）
——UTF-16
——UTF-32
…………

编码——————解码
采用的不是同一本对照表，会出现“乱码”。

基本数据类型

默认值：0

**整数型：
bety (1个字节) 取值范围【-128~127】
short(2个字节) 取值范围【-32768~32767】
int(4) 取值范围【-2147483648~2147483647】
long(8)

***浮点型：
float(4)
double(8)

***布尔型：
boolean(1个字节) (false == 0)

***字符型：
char(2一个字节) 取值范围【0~65535】//char 和 short 表示的范围是一样的，不过char可以表示更大的正整数。

成员变量没有赋值，系统自动赋默认值。

字节(byte)

1 byte = 8 bit [1个字节 = 8个比特位]
一个比特位表示一个二进制位1/0

1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB

转义符

\出现在特殊字符之前会将其转换成普通字符
\n -----换行符
\t ------ 制表符

整数型

java语言中的"数型字面值"默认被当成int类型处理，要让"值"被当做long类型处理的话，需要在字面值后面加上L。

三种表示方法：

十进制：缺省默认表示方法——————例如：10；//10
八进制：以0开始————————例如：010；      //8
十六进制：以0x开始———————例如：0x10；   //16

自动类型转换：小容量可以自动转换为大容量：

例：
long x = 456; //把int类型的456转换为long类型的变量x

强制类型转换：大容量转换为小容量：

例：

long x = 100l; int a = (int) x
long k = 2147483648L; int e = (int) k;//强制类型转换会损失精度谨慎使用

*Sun公司对byte、short、char有优待政策，只要没超取值范围，可以直接赋值。
例：

byte b = 50;
b = 127;

面试题：

long z = 2147483648;//超出int类型范围，应在后面加L

double的精度问题

double的精度太低[ 相对来说的]，不适合做财务软件。
财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中
为程序员准备了精确度更高的类型，只不过这种类型是一种引用
数据类型，不属于基本数据类型，它是: java.math.BigDecimal
其实java程序中SUN提供了一套庞大的类库，java程序员是基于这套
基础的类库来进行开发的。所以要知道java的SE类库的字节码在哪儿,
要知道java的SE类库的源码在哪儿?
SE类库字节码: C: \Program Files (x86) \Java\jdk1.7.0 _75\jre\lib\rt,jar
SE类库源码: C: Program Files (x86) \Java\jdk1.7.0 75src.zip
例如: string. java和string . class
我们的(String[] args) 中的string使用的就是string, class字节码文件

原码，反码，补码

计算机在任何情况下底层表示和储存的的都是补码形式。

正数的补码：和原码相同。
负数的补码：负数的绝对值对应的二进制码—所有的二进制位取反，再加一。

例：求-5的补码。
-5对应正数5（00000101）→所有位取反（11111010）→加1(11111011)
所以-5的补码是11111011。

关系运算符

        int c = 10;
        int d = ++c;   //加号在前面，先自身+1.

逻辑运算符

& ---------逻辑与【并且】（两边算子都是true，结果才是true）
|  ---------逻辑或【或者】（两边算子有一个是true，结果就是true）
!   ---------逻辑非（取反，!false 就是true， !true就是false）
^  ---------逻辑异或（两边只要不一样，结果就是true）

&&  ---------短路与（前面的结果是false，整个表达式就确定为false，不执行后面，执行效率高）

例：

int x = 10;
int y = 8;
System.out.println(x < y && ++x < y);
System.out.println(x);//10

|| ---------短路或（两边算子都是true，结果才是true）

扩展类算符

+=
-=
*=
/=
&=
扩展类的运算符不改变原本的数据类型。
例如：

byte i = 10;
i += 5;//(byte)(x + 5)
System.out.println(i);

三元运算符\三目运算符\条件运算符

当表达式是true的时候，选择1作为结果。
当表达式是false的时候，选择2作为结果。

boolean sex = true;
char sex ? '男' ： '女’;
System.out.println(sex);

接收用户键盘输入

java.util.Scanner s = new java.util.Scanner(System.in);
String str = s.next();
int num = s.nextInt();

控制语句-----if

控制语句switch

		switch("+"){
		case "+":
			执行这条语句;
			break;
		case "-":
			result = num1 - num2;
			break;
		 }

循环语句

for（int i = 0 ;i <= 10 ;i++ ）{
	System.out.println(i);
}

int i = 0;
while{
	System.out.println(i);
	i++;
}
do while//先执行程序在循环
break//直接中断循环
for(int i = 0;i <10 ; i++)
{
	if(i == 5);
	break;	  		//循环直接结束
}
System.out.println(i); 	//输出0 1 2 3 4
continue//停止本次循环，继续下一轮循环
for(int i = 0;i <10 ; i++)
{
	if(i == 5);
	continue;	  		//本次循环停止，进入下一循环
}
System.out.println(i); 	//输出0 1 2 3 4 6 7 8 9

用for循环找出 1~10000之内的素数，每8个换一行

public class ForTest{
	public static void main(String[] args){
	int count = 0;
	//从1到10000循环一遍；
	for(int i = 1; i <= 10000; i++)				
	{
		//做标记，默认true
		boolean isSuShu = true;		  	      	
			for(int j = 2; j < i ;j++){		//用for循环遍历出比i小的j
				if(i % j == 0){				//素数就是除了1和i本身，其他都除不尽
					isSuShu = false;		//就用2和小于i的数进行取余运算
					break;					//如果i除j没有余数，说明不是素数
				}
			}
			if(isSuShu == true){		//如果是素数，就进行输出。i+是素数
				System.out.println(isSuShu ? i + "是素数" : i + "不是素数")；
				count ++;				//同时count加1运算
				if(count == 8){			//直到加到8，输出换行符，同时count归零。
					System.out.println();
					count = 0;
				}
			}
		}
	}
}

方法（Method）/函数（Function）

方法的本质就是一段代码片段，这段片段可以完成某个特定的功能，并且可以被重复的使用

方法执行内存分析

入栈\压栈（push）
出栈\弹栈（pop）
在这里插入图片描述

方法的重载（Overload）

功能相似的时候，方法名可以相同
功能不同的时候尽可能让方法名不同。

——方法重载需要满足的条件
1…在同一类中
2…方法名相同
3…参数列表不同：
—数量不同
—顺序不同
—数据类型不同

——方法重载和方法名+参数列表有关系
——和返回值类型无关
——和修饰符列表无关

public static int sum(int a, int b){  //两个int类型的值相加。
	return a + b ;
}
public static double sum(double a, double b){	//两个double类型的值相加。
	return a + b ;
}
public static long sum(long a, long b){	//两个long类型的值相加。
	return a + b ;
}

递归问题(Recursion)

1、递归就是方法自身调用自己
2、递归是很耗费栈内存的，递归可以不使用尽量别用
3、递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误【jvm停止工作】
4、即使有结束调节也有可能错误，因为递归太深了

public class Recursion{
	public static void main(String[] args){
		System.out.println(accumulation(4));
	}
	public static int accumulation(int n){
		if ( n == 1){
			return 1;
		}
			return n + accumulation(n - 1);
	}
}

在这里插入图片描述

面向过程和面向对象的区别

面向过程【集成显卡】：关注的核心是【具体过程】【因果关系】。
-————————例如蛋炒饭
—优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本低。
—缺点：很难解决复杂的业务逻辑，另外这样的方式导致软件元素之间的“耦合度”非常高，只要其中一环出了问题，整个系统都会受到影响，导致软件的“扩展力”差。另外，由于没有独立体的概念，导致组件没办法完成重复使用。

面向对象【独立显卡】：关注的核心是对象【独立体】能完成哪些功能。
——————————例如茄子盖饭
—优点：耦合度低，扩展力强，更容易解决现实世界中的复杂业务逻辑，组件复用性强。
—缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计。

面向对象的三大特征

——封装
——继承
——多态
采用面向对象的方式开发一个软件【整个生命周期中贯穿使用OO面向对象方式】
——面向对象分析方法：OOA
——面向对象设计方法：OOD
——面向对象程序设计：OOP

类

——类在现实世界中不存在，是虚拟模板、概念，是人类大脑思考抽象的结构。
——类代表了一类事物。例如：同学、汽车、课桌、电脑
——在现实世界中，对象A和对象B有共同的特征，就可以进行抽象总结出一个模板，这个模板就被称为【类】

重点：
——类描述的是对象的共同特征，例如：身高特征。
在访问这个特征的时候，必须要先创建对象，通过对象访问，具体到对象上后，结果也不同。
——类描述的是【状态 + 动作】
状态信息：名字、身高、性别、年龄
动作信息：吃、唱歌、跳舞、学习

类>>>>>【实例化】>>>>>对象（实例/instance）
对象>>>>>【抽象】>>>>>类

类的定义
语法结构：

[修饰符列表] class 类型{
		属性;		//描述对象的状态信息：名字、身高、性别、年龄
		方法;		//描述对象的动作信息：吃、唱歌、跳舞、学习
}

————属性通常用变量的方式来定义，在类体中，方法体外的变量被称为成员变量，成员变量没有赋值时，系统赋默认值：一切向0看齐。

————由于每个学生的学号都不同，所以要访问学号，必须要创建对象
————信息不能通过【类】去访问，所以这种成员变量又被称为实例变量。

public class Student{
	int no;					//学号，要访问学号，必须要创建对象
	String name;			//姓名
	boolean sex;			//性别
	int age;				//年龄
	String address;			//住址
}
具体到对象上后，结果也不同。

所有的类都是引用数据类型

对象

——对象是实际存在的个体。

1、描述一下整个软件开发的过程：
2、程序员先观察现实世界，从现实世界中寻找对象
3、寻找了N个对象后，发现所有对象都有共同特征
4、在大脑中形成了一个模板【类】
5、Java程序员可以通过java代码来表述一个类
6、Java程序中就有了类的定义
7、然后通过类可以创建新的对象
8、有了对象之后，可以让对象协作形成一个系统

new

new是一个运算符，作用是：实例化对象。用法：new 类名();

new运算符的作用是创建对象，在JVM堆里开辟新的内存空间

堆内存

方法区内存：在类加载的时候，class字节码字节码代码片段被加载到该内存空间当中
栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在堆内存中压栈。
堆内存：new的对象在堆内存中储存
在这里插入图片描述

什么是对象？？

——new运算符在堆内存中开辟的内存空间称为对象。

什么是引用？？

——引用保存了内存地址。(s变量保存另一个java对象在堆内存中的地址)

访问实例变量的语法格式：
读取数据：引用.变量名
修改数据：引用.变量名 = 值

public class Student{
	int no;					//学号，要访问学号，必须要创建对象
	String name;			//姓名
	boolean sex;			//性别
	int age;				//年龄
	String address;			//住址
}

public class OOTest{
	public static main(String[] args){
		int i = 10;		//new Student()是一个学生对象
		Student s = new Student();//Student是一个引用类型数据，s是一个变量名
//s变量中保存的是另一个java对象在堆内存中的地址 
			//读取数据
		System.out.println("学号 = " +   s.no);		//0
		System.out.println("姓名 = " +  s.name);	//null
		System.out.println("年龄 = " +  s.age);		//0
		System.out.println("性别 = " +  s.sex);		//false
		System.out.println("住址 = " +  s.address);	//null
		s.no = 10;				//修改数据
		System.out.println(s.no);					//10
	}				
}

eclipse

重点窗口介绍：
Package Explore / Navigator / Project Explore：可以看到java源文件
Console：控制台窗口

工作区workspace中基本的单元是：Project（工程 / 项目）

1、创建工程
新建—new–>Java Project【JavaSE工程】
（1）制定java工程的名称一般全部小写
（2）制定java工程存放目录
（3）java的运行时环境：JRE的配置
（4）Project layout：工程的目录布局
—多数情况下都是选择，两个独立的文件夹存储原码（src）和字节码（bin）
2、在src目录上新建软件包：
新建—new–>package
给package起名包是java
3、在包下新建java类：new–>class【可以选择生成main方法】

4、怎么链接源码
打开某个.class字节码文件，当没有看到源码的时候：
点击Attached Source：
-Workspace… 【源码在当前工作区当中】
-External File … 【源码在某个压缩包当中】
-External Folder … 【源码在某个目录当中】

面向对象————封装

封装的好处：
1、复杂型封装对外提供简单的操作入口（电视机）
——get
——set
2、封装之后才会成为真正的对象真正的"独立体"
3、封装就意味着以后的程序可以重复使用，并且对这个事物适应性比较强，在任何场合都可以使用
4、封装之后。对事物本身。提高了安全性

封装的步骤

1、所有属性私有化，使用private关键字进行修饰，修饰的所有数据只能在本类中访问
2、对外提供简单的操作入口，以后外部程序想要访问其内部的属性，必须要通过简单的入口进行访问
（1）想修改age属性，调用set方法。et方法的命名规范：

	public void setAge(int a){	
		age =  a;
	}

2）想读取属性，调用get方法。get方法的命名规范：

	public int ageAge(){
		return age;
	}

背会：有static关键字修饰的方法调用：类型.方法名（实参）
没有static关键字的方法调用：引用.方法名（实参）

class Customer{
	String name;
	int age;
	public void setAge(int a){		//制定set方法
		if(a<=100 || a > 0){		//设定条件
			return;
		}
			age = a;		//赋值
	}
	public int getAge(){			//制定get方法
		return age;			//返回age的值
	}
}
class CustomerTest{	
	public static void main(String[] args){
		Customer c = new Customer();
		c.setId(20);			//赋值
		System.out.println(c.getId());	//读取
	}
}

构造方法/构造函数/构造器/Constructor

//构造方法的语法结构
【修饰符列表】 构造方法名 （形式参数列表）{		
	构造方法体;
}
//普通方法的语法结构
【修饰符列表】 返回值类型 方法名形式参数列表）{  
	方法体;
}

对于构造方法来说，不需要制定返回值，也不能写void。

方法名必须与类名一致。

构造方法存在的意义是通过构造方法的调用
1、可以创建对象。
2、给实例变量赋初始值

//普通方法的调用
class Num{
	public static void main(String[] args){	
		ConstructorTest.num(10);//类名.方法名(实参);
	}
	public static int num(int a){	
		return a;
	}
}
//构造方法的调用-------new 构造方法名/类名()
class User{ 
//当一个类中没有定义任何构造方法，系统默认给该类提供一个无参数的构造方法，该方法被称为缺省构造器     
	public User(){			  		 								
	}
//如果一个类显示的构造方法定义出来了就不再提供，建议开发中手动提供无参数，因为非常常用
	public User(int i){
	}
//构造方法支持方法重载机制，在同一类中写多个构造方法，就会形成方法重载机制
	public User(String name){
	}
	public User(int i , String name){
	}
}
class ConstructorTest{
	public static void main(String[] ags){
		User u1 = User();	//引用.方法名（实参）
		User u2 = User(10);
		User u3 = User("张三");
		User u4 = User(122,"李四`在这里插入代码片`");
		
	}
}

参数传递

其本质都是值传递，有可能这个值是一个地址，指向java对象。
在这里插入图片描述

This关键字

1、翻译为“这个”。
2、this是一个引用，是一个变量，变量中保存的地址指向了自身，this储存在jvm堆内存jvm对象内部。
3、创建100个java对象，每一个对象都有this，也就是说有100个不同的this。
4、this可以出现在“实例方法”当中，this指向当前正在执行这个动作的对象。（this代表当前对象）
5、this在多数情况下都是可以省略。
在这里插入图片描述
顾客例子：

在这里插入图片描述

class Test{
	public static void main(String[] args){
		//调用doSome方法
		doSome();
		//调用doOther方法
		Test t = new Test();
		t.doOther();
	}
	
	//有static的话，不需要访问对象中的属性
	//所以调用的时候就用类名.的方式来调用
	//所以不能用引用.的方式来调用,就不能写this.name
	//例如
	public static void doSome(){
		System.out.println("do some!");
	}
	//如果没有static，就是实例方法。
	//就要用引用.调用，如果没有对象，就要先创建对象。
	//例如
	public void doOther(){
		System.out.println("do other！");
	}
}

static

1、static翻译为静态的

2、用static修饰的方法是静态方法，直接用类名调用

3、static修饰的变量是静态变量，创建时赋初始值，并作为该类对象共同属性

4、所有static修饰的元素都称为静态的，都使用“类名.”的方式访问

5、方法什么时候定义为静态的？
方法描述的是动作，当所有的对象执行这个动作的时候，最终产生的效果是一样的，这个动作就已经不属于某一个对象的动作了，可以将这个动作上升为类级别的动作，模板级别的动作。

6、静态方法中无法直接访问实例变量和实例方法

用static定义“静态代码块”：
1、语法格式：

static{
	Java语句;
}

2、静态代码块在类加载时执行，并且只执行一次。
3、静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次进行
4、作用是什么？怎么用？用在哪儿？什么时候用？
——和具体需求有关，例如项目中要求在类加载的时刻执行代码完成日志的纪录。那么这段纪录日志的代码就可以写到静态代码块中
——静态代码块是java为程序员准备的一个特殊的时刻，这个特殊的时刻被称为类加载时刻
——通常在当中完成预备工作，先完成数据的准备工具，例如：初始化连接池，解析XMI配置文件。

实例语句块/代码块【了解】

1、实例代码块可以编写多个，也是自上而下
2、示例代码块在构造方法执行之前执行，构造方法执行一次，示例代码块对应执行一次
3、示例代码块也是java语言程序员准备的一个特殊时期，被称为对象初始化时机

public Test(){
}
{
	System.out.println(1);
}
{
	System.out.println(2);
}
{
	System.out.println(3);
}
public static void main(String[] args){
	new Test;
}

面向对象回顾：

class类
{
	静态代码块；------------类加载的时候只执行一次。
	实例代码块；------------构造方法执行之前执行，方法每执行一次，该代码块执行一次。

	静态变量；------------类加载时初始化，存在方法区中，通过“类名.”访问
	实例变量；------------构造方法执行的时候初始化，存在java对象内部，引用.

	构造方法；------------new
	
	静态方法；------------类名.
	实例方法；------------引用.
}

大多数方法都定义为实例方法，一般一个行为或一个动作在发生的时候，都需要对象的参与。

但是也有例外，例如大多数“工具类”中的方法都是静态方法，因为工具类就是方便编程，为了方便方法的调用，自然不需要new对象是最好的。

继承

在这里插入图片描述
1、基本作用是：代码复用。

2、最重要的作用是有了继承之后才有“方法的覆盖”和“多态机制”

3、继承语法格式：
【修饰符列表】 class 类名 extends 父类名{
类体 = 属性 + 方法
}

4、java语言当中的继承只支持单继承，一个类不能同时继承很多类，在C++中支持多继承。

5：关于继承中的一些术语：
B类中继承A类，其中：
A类称为：父类、基类、超类、superclass
B类称为：子类、派生类、cubclass

6、子类继承父类都继承哪些数据呢？
——私有的不支持继承
——构造方法不支持继承
——其他数据都可以被继承

7、虽然java语言当中只支持单继承，但是一个类也可以间接继承其他类，例如：
C extends B{
}
B extends A{
}
A extends T{
}
C直接继承B类，但是C类间接继承T、A类。

8、假设一个类没有显示的继承任何类，该类默认继承JavaSE当中提供的java.lang.Object类。

方法的覆盖/方法重写（override[官方]/overwrite）

在这里插入图片描述
1、什么时候使用方法重写
-当父类中的方法已经无法满足当前子类的业务需求
-子类有必要将父类继承过来的方法进行重新编写
-这个重新编写的过程称为方法重写/方法覆盖。

2、什么条件满足之后发生方法重写？
-方法重写发生在具有继承关系的父子类之间
-方法重写的时候，返回值类型相同，方法名相同，形参列表相同
-方法重写的时候，访问权限不能更低
访问权限从低到高，private—default-----protected----public
-抛出异常可以更多，不能更少
3、建议方法重写的时候尽量复制粘贴，不要编写，容易出错，导致没有产生覆盖。

4、注意：
私有方法不能继承，所以不能覆盖
构造方法不能继承，所以不能覆盖
静态方法不存在覆盖
5、只针对方法，不针对属性
6、重写的方法会有一个绿箭头

多态

在这里插入图片描述
1、ava程序分编译阶段和运行阶段。
在编译期，c的引用类型是Animals。
在运行期，创建的对象是Cats对象。

-编译阶段编译器检查引用的数据类型为Animals，由于Animals.class字节码当中有move()方法，所以编译通过了，这个过程被称为静态绑定

在这里插入图片描述
2、在编译阶段，编译器只知道c的引用类型是Animals，他没有catchMouse这个方法，所以直接报错。

3、这时候需要强制类型转换，将父类型Animals转换为子类型Cats。
适用条件：当调用的方式子类型中特有的，在父类型当中不存在，必须进行向下转型。
在这里插入图片描述

4、
向下转型(downcasting)
父类型–>子类型：强制类型转换【需要加强转符】
例：Cats d =（Cat）c；

向下转型（upcasting）
子类型–>父类型：自动类型转换
例：Animals c = new Cats；

空指针异常（NullPointerException）

有一个引用是空，访问的实例相关的数据，就会出现空指针异常。

避免，让这个引用不是空。

类型转换异常（ClassCastException）

在这里插入图片描述
避免：
1、以上异常，只有在强制类型转换的时候会发生，也就是说向下转型存在隐患！
2、向上转型只要编译通过，运行一定不会出问题。
3、向下转型编译通过，运行可能错误
4、怎么避免向下转型出现的ClassCastException呢？
使用instanceof运算符可以避免出现以上的异常。
5、instanceof
–格式：
（引用 instanceof 数据类型名）
执行结果类型是————boolean类型，可能是true/false

–假设：（ a instanceof Animals）
ture 表示：
a这个引用指向的对象是一个Animals类型
false表示：
a这个引用指向的对象不是一个Animals类型
在这里插入图片描述

下标越界异常(ArrayIndexOutOfBoundsException)

数组超过长度

数字格式化异常(NumberFormatException)

Interger a = new Integer("中文")

实际案例分析面向对象的优点

在这里插入图片描述
final关键字
1、final是一个关键字，表示最终的，不可变的

2、final修饰的类无法被继承

3、final秀的变量一旦被赋值之后，不可重新赋值

4、final修饰的实例变量必须要手动赋值，不再赋系统默认值

//手动赋值第一种方案
final int age = 10;
//第二种方案
final int age ;				//定义age实例变量
public FinalTest(){	//定义一个实例方法由于实例变量
this.age = 10;		//在实例方法执行的时候才会赋值，所以								
}					//这种方法也是可行的

5、final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，但是指向对象内部的值是可以改的。

final User u = new User(100);
u = new User(200);			//编译报错

常量

public static final 类型 + 常量名  =  值；

例：


public static final String GUO_JI = "中国";

包（package）

1、包名的命名规范：
公司域名倒序 + 项目名 + 模块名 + 功能名；
例如：
com.bjpowernode.oa.user.service;
org.apache.tomcat.core;

2、包名要求全部小写，包名也是标识符，必须遵守命名规则。

3、一个包对应一个目录，目录之间使用“.”隔开

4、使用了package机制之后，应该怎么编译，怎么运行？
在这里插入图片描述

import

在这里插入图片描述

import需要写在包名之下，类名之上

访问控制权限修饰符

控制元素的访问范围
	public 	表示公开的，在任何位置都可以访问
	protected	同一个包，或者它的子类
	缺省	同一个包
	private	表示私有的，只能在本类中访问
可以修饰类，变量，方法

抽象类(abstract)

1、在class前添加abstract关键字就是抽象类。

2、抽象类是无法实例化的，不能new对象，所以抽象类是用来被继承的。

3、final和abstract不能联合使用，这两个是对立的。

4、抽象类的子类可以是抽象类，也可以是非抽象类。

5、抽象类虽然无法实例化，但是可以有构造方法，这个方法供子类使用。

6、抽象类中不一定有抽象方法啊，抽象方法必须出现在抽象类中。

7、抽象方法怎么定义？抽象方法没有方法体

public abstract void dosome();

----------------------------------------【重点】----------------------------------------
8、一个非抽象类继承抽象类，必须要将抽象类中的抽象方法进行重写实现。

面试题

没有方法体的都是抽象方法吗？错误！
public native int hashcode();
这个方法底层调用了C++写的动态链接库程序。

接口的基础语法(interface)

1、接口也是一种引用数据类型

2、接口是完全抽象的（抽象类是半抽象），也可以说接口是特殊的抽象类

3、语法：

【修饰符列表】 interface 接口名{
	}

4、接口支持多继承：

interface C extends A,B{
}

5、接口中只包含这两部分：
（1）常量
（2）抽象方法

6、接口中所有元素都是用public修饰的

7、接口中的抽象方法的public abstract可以省略

8、接口中常量的public static final可以省略

9、接口中方法不能有方法体。

10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。

11、一个类可以实现多个接口。

12、extends和implements可以共存，extends在前，implements在后

13、使用接口写代码的时候，可以使用多态【父类型引用指向子类型对象】

接口在开发中的作用

解耦合
例：
顾客——菜单——厨师

JDK类库的根基：Object的几个方法

1、equals
以后所有类的equals方法都需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写
规则：自己定，主要看什么和什么相同时表示两个对象相等。

（1）源代码:

public boolean equals(Object obj){
	return(this == object)
}

(2)目的：通过equals方法，编程的过程当中，都要通过equals方法来判断是否相等。
（3）重写代码：

public boolean equals(Object obj){
	if(obj == null || !(obj instanceof Mytime)){
		return false;
	}
	if(this == obj){
		return true;
	}
	Mytime t = (Mytime) obj;
	return this.year == t.year && this.month == t.month && this.day == t.day;
	}
}

2、toString
以后所有类的toString（）方法都需要重写，
System.out.println(引用);这里会自动调用“引用”的toString方法，String类是SUN写的，toString方法已经重写了。
（1）源代码：

public String toString(){
	return getClass().getName() + "@" + Integer.toHexString(hashiCode());
}

（2）默认实现：类名 + @ + 对象的内存地址转换为十六进制
（3）目的：返回对象的字符串表示形式，结果应该为简介、详实、易阅读，建议所有子类都重写此方法

3、finalize()方法
(1)源代码:

protected void finalize() throws Throwable{}

(2)finalize（）只有一个方法体，里面没有底阿妈，而且这个方法是protected修饰的。
（3）这个方法不需要程序员手动调用，JVM的垃圾回收期负责调用。
（4）当java对象即将被垃圾回收的时候，负责调用
（5）通常被用来纪录垃圾销毁时机。
例如：

public vlass Test{
	public static void main(String[] args){
		Person p = new Person();
		p = null;
		System.gc(); //建议启动垃圾回收器
	}
}
class Person{
	protect void finalize() thorws Throwable{
		System.out.println("即将被销毁")
	}
}

4、hashCode方法
(1)源代码

public native int hashCode();//底层调用C++程序

hashCode()返回的是一个哈希码，这个方法的执行结果可以等同看做一个java对象的内存地址。

public class Test{
	public static void main(String[] args){
		Object o = new Object();
		int hashCodeValue = o.hashCode();

		System.out.println(hashCodeValue);
		
		MyClass mc = new MyClass();
		int hashCodeValue2 = mc.hashCode();
		System.out.println(hashCodevalue2);
		MyClass mc2 = new MyClass();
		System.out.println(mc2.hashCode());
	}
}
class MyClass{
}

匿名内部类

可以不写接口的实现类，而是直接在接口中new

public static void main(String[] args){
	MyMath mm = new MyMath;
	//此处用new Compute(){}来代替接口的实现类
	mm.mySum(new Compute(){
		public int sum(int a ,int b){
		return a + b;}
} , 100,200);

}

一维数组

1、Java语言中的数组是一种引用数据类型，其父类是Object
2、数组实际是一个容器，可以容纳多个元素
3、可以储存基本数据类型，也可以储存引用数据类型
4、如果储存的是对象，那就是储存的对象地址
5、数组因为是引用类型，存在堆内存中，所有元素都有地址，而且是连续的，一般用第一个元素的地址来代表数组的地址
6、java数组一旦创建，长度就不可变，只能拷贝。
8、分类：一维数组，二维数组，三维数组，多维数组
9、所有数组对象都有.length属性，用来获取个数
10、要求数组中元素的类型统一，int [] a ，其中所有元素都是int类型的
11、每个元素都有下标，第一个元素是 0 ，最后一个元素的下标是 Lenth - 1；
非常重要！需要取出或者修改元素，都需要下标来进行

12、语法格式

//声明一维数组；
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
//静态初始化
int[] array = {1,2,3,4,5,6}
//动态初始化语法格式
int[] array = new int[5];   //5表示元素个数，每个元素默认值为0

String[] names = new String[6]; //初始化6个长度的String类型的数组，每个元素默认值null。

//存
a[0] = 100;
//取
System.out.println(a[0]);

一维数组的遍历

int[] a = new int[5];
for(int i = 0; i < a.length; i ++){
	System.out.println(a[i]);
}
//如果输出a[6],会发生下标越界异常

main方法中的String[] args

这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来。

public static void main(String[] args)

JVM默认传递过来的这个数组对象的长度默认为0；
通过测试得出，args不是null。

这个数组是留给用户的，可以在控制台上输入参数，会被自动转换为String[] args

所以main方法上的这个数组是用来接收用户输入参数的

数组中储存的类型为引用数据类型

class Test{
	public static void main(String[] args){
		/*
		Animals a1 = new Animals();
		Animals a2 = new Cat();
		Animals a3= new Dog();
		Animals[] a = {a1,a2,a3};
		*/
		Animals[] a = {new Animals(),new Cat(),new Dog()};
		
		for (int i = 0; i <a.length ; i++){
			/*
			Animals a = animals[i];
			a.move;
			*/
			Animals b = a[i];
			b.move();
		}
		for (int i = 0; i <a.length ; i++){
		//	子类独有的方法，需要强转
			if(a[i] instanceof Cat){
				Cat c = (Cat)a[i];
				c.catchMouse();
			}
			else if(a[i] instanceof Dog){
				Dog d = (Dog)a[i];
				d.shout();
			}
		}
	}
}
class Animals{
	public void move(){
		System.out.println("Move");
	}
}
class Cat extends Animals{
	public void move(){
		System.out.println("Cat move！");
	}
	public void catchMouse(){
		System.out.println("猫抓老鼠");
	}
}
class Dog extends Animals{
	public void move(){
		System.out.println("Dog move!");
	}
	public void shout(){
		System.out.println("Wang!");
	}
}

数组的扩容（需要拷贝）

//java中的数组拷贝
System.arraycopy(五个参数);

拷贝源 + 拷贝源的位置 + 拷贝目标 + 目标位置 + 长度
例如：

int[] a = {10,22,33,45,1};
int[] b = new int[20];
System.arraycopy(a,1,b,4,3)
//a 代表拷贝源， 1 代表第二个元素， b 代表目标 , 4 代表起始位置， 3代表拷贝三个元素 ，输出应为 ： 0 0 0 0 22 33 45 0 0

数组工具类

在这里插入图片描述

冒泡排序算法

在这里插入图片描述

选择排序算法

在这里插入图片描述

用二分法查找

在这里插入图片描述

Arrays工具类

在这里插入图片描述

反射机制

反射机制的作用：
反射机制可以直接修改字节码文
在哪个包下？
java.lang.reflect
反射机制相关的重要的类。
java.lang.Class----代表字节码文件
java.lang.reflect.Method----代表字节码中的方法字节码
java.lang.reflect.Constructor----代表字节码中的构造方法字节码
java.lang.reflect.Field----代表字节码中的属性字节码

Annotation注解

JDK中有三个注解：主要用于对其他元素进行描述。包括Annotation，Class ， Method， Field
@Deprecated修饰方法，调用时显示已过时
@SuppressWarnings("all") 抑制所有警告
@Override重写，只能出现在方法上

自定义注解

public @interface MyAnnotation(){
}

元注解

修饰注解的注解

//表示该注解能出现的位置
@Target(ElementType.METHOD)
//保存时间
@Retention(RetentionPolicy.SOURCE)
SOURCE = 该注解仅出现在源代码中，而被编译器丢弃；
CLASS（默认）
= 该注解保留在class文件中，加载到JVM虚拟机时丢弃
RUNTIME = 注解保留在程序运行期间，可以通过反射获得类上的注解

Geneartion_Z

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE

1、HelloWorld!public class HelloWorld{ //class-定义一个类；HelloWorld表示一个类名//以下方法体是一个程序的主方法，是入口 public static void main(String[]args){ //方法体 //public 公开的；static 静态的；void 空； System.out.println("HelloWorld!") }}...
复制链接

扫一扫