首页  思维导图  详情

JAVA

2021-06-26 19:54:48   17  举报





AI智能生成

java

学霸笔记

计算机类

学习笔记

学校教育

作者其他创作

大纲/内容

基础类

java封装类

Integer
Character

装箱

1、构造器
Integer i=new Integer(4)

静态方法：Integer.valueOf()

自动装箱：Interger i=4;

拆箱

obj.intValue()

自动拆箱 int i=obj(Integer类型）

Integer类的缓冲区

Integer在自动装箱的时候。会调用Integer.valueOf()方法，如果在-128~127之间的数字就会从缓冲区数组中直接拿并返回
如果不在这个范围，就会直接new一个新的Integer对象

Stringl类（不可变字符串）

构造器

无参构造器String str=new String() 等价于String str=new String("")

将数字转换为String 类型
String str=new String(ch[])

常用方法

charAt():获取指定索引位置的字符

codePointAt():获取当前字符串中参数指定的索引位置的字符的ascii码

compareto():比较两个字符串（按照字典顺序）
如果第一个字符相同，则比较第一个字符，如果某个字符不行等，则用ascii码做减法
如果某个字符串完成都一致，则返回当前字符串长度—参数字符串长度

concat()字符串拼接

startWith(),endsWith():以什么开头，以什么结尾

indexOf:返回参数字符第一次出现的位置 lastIndexOf()

str.getBytes():将字符串转换为byte类型的数组

replace():经当前字符串的第一个参数替换成第二个参数后返回新的字符串

str.split():将字符串按指定的字符串分割（正则表达式），返回一个String 类型的数组

substring(4,9):截取字符串，左包含，右边不包含

length（）：字符串的长度

trim():去除当前字符串首尾的字符

toLowerCase(),toUpperCase:将字符串全改成大写（小写）字母

matches():判断当前字符串是否匹配参数指定的正则表达式

字符串常量池

String str1="abc" 当定义str1的时候，先回去常量池中有没有这个abc字符串，如果有直接指向它，没有就放一个abc到常量池中去，然后指向它

String s=str.intern()方法的作用：如果str在常量池中，那么s就指向常量池中的abc,如果str不在常量池中，那么就会在常量池中放一个abc然后指向它

可变字符串:StringBuffer,StringBulider

常用方法

append(String str):字符串拼接

delete(int start,int end):删除字符串

insert(int start,String str):插入字符串

reverse（）字符串翻转

toString() 转换成字符串

String 、StringBuffer、StringBuilder区别

这三个类都是操作字符串的

String 类是一个字符串常量类，一旦定义不能改变，所以在做大量字符串拼接的时候，实际指向是新字符串，所以耗时

StringBuffer,StringBuilder是可变的字符串序列，自带缓冲区，可以进行字符串的拼接。效率高

StringBuffer是线程安全的，StringBuilder是线程不安全的

Math类

Math.pow(m,n):n次方

Math.sqrt(a):开方

Math.cbrt(a):开立方

Math.ceil():向上取整

Math.floor():向下取整

Math.round(10.5):四舍五入

Math.random():默认【0，1）

BigDecimal类

作用：精确计算浮点数

创建方式：BigDecimal bd=new BigDecimal(“1.0”)。

方法

b1.add(b2):加法

b1.subtract(b2)：减法

b1.multiply(b2)：乘法

b1.divide(b2,2,RoundingMode.HALF_UP)：除法
RoundingMode.FLOOR向下取整 CEILING向上取整 HALF_UP 四舍五入

Random类

r.nextInt():ini类型范围的整数

Date类

构造方法

无参构造方法表示当前系统时间

有参构造方法，参数为指定的日期，但是要注意，默认是从1900年开始算的
默认月份是0~11月
Date date=new Date(2020-1900,2-1,22)

常用方法

date1.before(date2):判断date1是否在date2之前

date1.after(date2):判断date1是否在date2后面

date.getTime():返回从1970到date对应日期之间的毫秒数

SimpleDateFormat类

Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String t = sdf.format(date);//格式化时间，将date类型转换成字符串类型
System.out.println(t);

Calendar类

方法

get(字段）：获取指定字符段的值

set(字段。值）：设置指定字段的指定值

add(字段，值）：在指定的字段添加或者减去指定的值

//创建一个Calendar对象 c表示系统当前时间
Calendar c = Calendar.getInstance();

System类

常用方法

System.currentTimeMillis()

- 返回当前系统时间的毫秒数从1970年开始计算

System.exit(0)

- 终止Java虚拟机的运行参数表示终止的状态 0表示正常退出

正则表达式

转义字符

\W:查找单词字符

\w:查找非单词字符

\d:查找数字

\D：查找非数字字符

\s:查找空白字符（非空格）

\S：查找非空白字符

量词

n{X,Y}:前面的n模式连续出现至少X次，最多Y次

作用

匹配

mathes(String regex):参数为正则表达式

替换

spllit(String regex)

切割

replaceAll(String regex,String newString)

查找

1、创建Pattern对象：Pattern pattern=Pattern.compile(正则表达式）
2、创建匹配器对象：Matcher matcher=pattren.matcher(str)
3、获取满足正则表达式规则的字符串：matcher.group();

Object类

介绍

Object类是所有Java类的超类。所有的类都直接或者间接的继承了Object类
Object类定义的方法会被所有类继承，因此所有的java对象都可以调用Object类中定义的方法

常用方法

clone（）

使用该方法创建一个obj的副本，也就是创建一个obj同类的对象

finalize()

GC垃圾回收机制：在Java中提供了GC垃圾回收机制，扫描JVM内存中的对象，通过“可达性分析算法”
判断对象是否为无用对象，如果对象为无用对象标记为垃圾对象，堆区会进行回收。

当GC判断某个对象为无用对象时，就会有由JVM让此对象调用finalize方法标记为垃圾对象，进到回收队列

触发手动回收：System.gc()

wait\notify\notifyAll

让当前线程进入休眠状态，知道调用notify或者notifyAll来唤醒

hashCode()

根据hash算法由对象的存储地址推算出一个int类型的值

原则上不同对象的hash码不同。但是不保证不相同。但一定保证同一个对象的hash码相同

toString()

如果没有重写toString，则返回当前对象的包名.类名@16进制的hash码

如果打印一个对象，相当于打印此对象调用toString方法

equals()

如果没有重写此方法，则Object类中比较规则就是用==进行比较，比较两个对象的hash码是否相等

如果重写该方法，则按重写的规则进行比较

String 类中对equals方法进行了重写，比较两个字符串的内容

getCLass()

获取当前对象的类信息

集合类(java.util)

特点：长度可以改变：及各种丰富的操作元素的方法：集合中可以存放引用类型的数据

分类

单列集合 Collection(j接口）

常用方法

add方法向集合集合中添加元素

clear方法,清空集合中所有元素

contains方法判断集合是否包含某个元素

isEmpty判断集合是否为空

remove方法移除集合中元素，返回boolean类型。如果集合中不包含次元素，则删除失败

size()返回集合中元素的个数

toArray将集合转换成数组

addAll 向一个集合中添加另一个集合

containsAll 判断一个集合中是否包含另一个集合

子类

List(有序，可重复，有下标）

ArrayList（数组）

常用方法

add(int index, E element)

remove(int index)

set(int index, E element)

get(int index)

subList(int beginIndex,int endIndex)

list.listIterator();

遍历三种方式

1、迭代器

2、for循环

3、foreach循环

ArrayList、LinkedList、Vector的区别

ArrayList和Vector底层实现采用数组实现，查询快，增删慢，LinkedList底层实现是双向链表，查询慢，增删快

ArrayList在添加元素时，才会去扩容数组，默认长度为10，Vector在创建对象时就创建长度为10的数组

ArrayList是线程不安全的，Vector是线程安全的

LinkedList（双向链表）

方法

list.addFirst("尼古拉斯");

list.addLast("亚洲舞王");

模拟栈结构

压栈：push()方法

弹栈：pop()方法

特点：先进后出

模拟队列结构

添加队列元素（尾部)：offer()

获取但不移除队列的头部的元素：poll()

特点：先进先出

遍历也是三种方式

Vector（数组）

Set(无序，不重复，无下标）

HashSet（哈希表）

去重原理

首先会比较两个对象的hashCode的值，如果hashCode的值不一样，则直接认为是两个不同的对象
如果HashCode值一样，就会比较两个对象的equals方法，如果equals方法返回false，表示两个对象是不同的对象
如果equals方法返回true，则表示两个对象是相同的对象，就不会向HashSet中添加元素

子类：LinkedHashSet

特点

有序（链表维护顺序），不重复，无下标

底层实现：LinkedHashMap

TreeSet（TreeMap)

特点

无序、无下标，不可重复

TreeSet在存储元对象时，对象必须实现Comparable接口，调用compareTo方法

compareTo方法作用：
排序：返回值大于0升序，小于0降序
去重：返回值为0，认为两个对象就是相同的对象

去重原理

如果compareTo方法的返回值为0，则认为是相同的对象

双列集合 Map

特点

由key和value组成，称之为键值对

键的特点：无序，无下标，不重复

值的特点：无序，无下标，可重复

子类

HashMap

常用方法

put(K key, V value)：存元素

get(Object key)：通过key来拿到value的值

boolean containsKey(Object key)

boolean containsValue(Object value)

V remove(Object key)

int size()

遍历

Set<String> keySet = map.keySet();
for (String key : keySet) {
System.out.println(key);
}

//返回map集合中所有的value
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}

//返回map集合中所有的key和value (Entry)
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}

底层实现原理（数组+链表+红黑树）

put流程

a:根据传递进来的key调用hash的扰乱算法得到一个hash值
b:如果是第一次添加，那么会初始化一个长度为16的Node数组
c:通过hash值与数组长度-1（15）做与运算，算出一个数组的下标，然后将元素加进去，有三种情况：
情况1：当前位置为null,直接放到当前位置
情况2：当前位置有Node节点
a:如果添加的Node节点与当前位置上的Node相同，则覆盖原来的元素
b:如果与链表上的元素都不想相同，

Hashtable

迭代器

方法

hasNext():判断迭代器是否有下一个元素

next():将游标移动到下一个位置
去除游标位置上的元素

注意事项

迭代器只能使用一次，迭代器迭代完成之后，迭代器的位置在最后一位

迭代器使用的时候不能多次使用next方法

迭代器在迭代的时候不要添加或者删除元素

Collections工具类

方法

Collections.reverse(List<?> list): 将集合中的元素反转

Collections.shuffle(List<?> list):将集合中的元素随机打乱

Collections.sort(List<?> list):将集合中的元素排序（必须要实现Comparable接口）

IO流(java.io)

网络编程(java.net)

线程(Thread)

行业基础

程序：为了模拟现实世界，解决现实问题，而使用编程语言编写的指令代码的集合

编程语言(了解）

C:嵌入式开发

C++：游戏开发方向

Python:数据分析、人工智能

java:web开发（大数据、android)

Php:web开发（中小型）

JavaScript:前端脚本语言

c#:.net平台

Golang:区块链

H5：html的第五个版本

易语言：桌面应用程序开发

ruby:脚本语言

环境安装

notepad++

改编码格式为ANSI

JDK安装

配置环境变量（path和HOME)

Java环境测试

java基础了解

Java简介

2009年被Oracle公司（甲骨文公司）收购

1996年java1.0(ME,SE,EE)

2014年jdk1.8

java体系架构

Java ME(微型版）

嵌入式开发

Java SE(标准版）

桌面应用程序（包含了Java的核心基础）

Java EE(企业版）

系统开发（后端系统）

Java语言特点

面向对象

简单性

跨平台（一处编译，处处执行）

多线程

高并发

安全稳定

编写第一个Java程序

1、编写源文件（。java结尾的文件）

2、编译源文件（.class文件，字节码文件）

3、运行程序

计算机语言分类（理解）

编译型语言：一次性将程序代码，编译成特定格式的文件(c语言）

解释型语言：逐行运行逐行翻译 (js.python)

编译+解释语言（Java）：先将代码编译成.class文件（字节码文件），再通过Java虚拟机（JVM）进行逐行翻译逐行执行

java中专有名词（理解）

JDK(Java Development Kit)

java开发工具包（提供Java开发所需的类、库）

JRE(Java Runtime Environment)

java运行环境（提供Java程序运行所需环境（JVM))

JVM(Java Virtual Meshine)

Java虚拟机（Java程序的翻译官）

java中类的概念

类是一个程序最小的组成单元

类的特点

一个Java结尾的文件中可以编写多个java类

但是一个.java文件中只能有一个用public修饰的类（主类）

使用public修饰的主类，必须和文件名一致（区分大小写）

建议：一个Java文件就编写一个Java类

Java程序的规范

1、代码缩进

table键，shift+table表示回退

2、代码注释

单行注释：//

多行注释：/* */

文档注释：/** */

3、命名规范

4、转义字符

计算机基础

计算机中单位

byte<kb<MB<GB<TB<PB<EB<ZB<YB<BB<NB<DB<CB<XB
别苦闷，国土配额资源不能动次序
都是1024的换算，其中1byte=8bit(位）

常用的dos命令

切换盘符

cd 文件夹名

打开文件夹

cd..

回到上一级

cls

清屏

echo 内容>文件名

创建文件并写入内容

del文件名

删除文件

mkdir 文件夹名

创建文件夹

rd文件夹名

删除文件夹

ping服务器地址

测试是否能连接远程主机

ping92.168.54.102

测试是否能连接局域网主机

ipconfig

查看本机IP地址

计算机中进制

javaj语法

变量：运行在内存中

使用变量

1、声明变量

语法：数据类型变量名

2、变量赋值

语法：变量名=值

3、使用变量

语法：打印输出

简写语法：数据类型变量名=值

特殊语法：数据类型变量名1，变量名2....=值

标识符的命名规范

1、标识符必须由数字、字母、下划线、美元符号组成

2、不能由数字开头

3、不能使用Java中的关键字和保留字

4、使用驼峰命名法（指的是标识符由多个单词组成）

小驼峰变量名、方法名
第一个字母小写，而后的每一个单词的首字母大写，例如：bigNum

大驼峰类名接口
每一个单词的首字母都大写，例如：HelloWorld

5、见名知意

数据类型

基本数据类型

整型

byte

1个字节

取值范围：-2^7~2^7-1

short

2个字节

取值范围：-2^15~2^15-1

int

取值范围：-2^31~2^31-1

long

8个字节

取值范围：-2^63~2^63-1

浮点型

float

4个字节

double

8个字节

字符型

char

2个字节

取值范围：0~65535

布尔型

boolean

1个字节

取值范围：true or false

引用数据类型

String ，类，接口，枚举，数组...

键盘录入

1、创建Scanner对象

Scanner input=new Scanner(System.in)

2、引入Scanner类

import Java.util.Scanner;

3、使用Scanner对象提供的功能扫描输入的整数、小数、字符串

数据类型转换

1、自动类型转化

数据兼容

小的类型转换成大的类型

2、强制类型转换

数据兼容

大的类型转换成小的类型

类型转换的细节

1、基本数据类型中大小关系：byte short(char) int long float double

2、Boolean类型不参加任何类型的数据类型转换

3、在Java程序中出现正数，默认都是int类型。出现的小数，都默认是double类型

4、在Java中，byte,short,char在参加运算前，会将其提升为int类型

5、如果发生强制类型转换会出现数据丢失

语法：（强转的类型）类型

运算符

算术运算符

+，-，*，/,%，++，--

关系运算符

<,>,<=,>=,==,!=

字符串比较内容，不用==,用equals

逻辑运算符

两个或多个表达式为真时为真

两个或多个表达式有一个为真时为真

表达式为真结果就为假，表达式为假，结果就为真

扩展

||：称之为短路或，只要有一个结果为真时就不会执行后面的表达式

&&：称之为短路与，只要有一个结果为假就不会执行后面的表达式

赋值运算符

=,+=,-=,/=,%=,*=

位运算符

按位与：&

相同位上，有一个为0，结果为0

按位或：|

相同位上，有一个结果为1，结果为1

按位亦或：^

相同位上，相同为0，不同为1

按位取反：~

左移：<<

右移：>>

无符号右移：>>>

三目运算符

语法：判断条件？结果1：结果2；
条件满足返回结果1，不满足返回结果2

控制流程语句

顺序语句

分支语句

if分支

简单的if分支

语法：if（判断条件（Boolean））{
满足条件执行的代码；
}

if......else分支

语法：if（判断条件）{
满足条件执行的代码；
}else{
不满足条件执行的代码；
}

多重if分支

语法：if（判断条件1）{
满足条件1执行的代码；
}else if（判断条件2）{
满足条件2不满足条件1执行的代码；
}...else if(...){
}else{
不满足前面所有的条件所执行的代码
}

嵌套if分支

语法：if（判断条件1）{
if（判断条件2）{
满足条件1，且满足条件2执行的代码；
}else(
满足条件，不满足条件2执行的代码；
}
}else{
不满足条件1执行的代码；
}

switch分支

语法

分支细节

1、case中的值不能重复

2、switch中的值只能是：byte、short、char、int、String、枚举类型

3、switch中做的是等值判断，不能做比较

4、break关键字：表示退出当前switch语句
如果不加break，难免会继续执行下面的代码，知道遇到下一个break

循环语句

for循环

while循环

do while 循环

嵌套循环

1、九九乘法表

2、三角形

while和do while 的区别

while循环：先判断在执行循环（有可能因此都不执行）

do while循环：限制性循环在判断（至少会执行一次循环）

do while的应用场景：当循环至少要执行一次的时候使用

break 和continue 关键字

break在循环中，表示结束当前循环

continue在循环中，表示结束本次，继续下一次循环

函数，数组，面向对象

eclipse基础

快捷键

方法

定义

完成某个特定功能而编写一个代码片段，可以反复使用

组成部分

public ：方法的访问修饰符(public、protected、缺省的、private)

static ：静态的 (静态的只跟静态的玩儿)

void ：空白的方法的返回值 (没有返回值，用void表示。有返回值，就写上返回值的类型)

main ：方法的名字 (满足标识符的命名规则(小驼峰))

(String[] args) ：方法参数(格式：数据类型参数名,数据类型参数名,...)

{} ：方法的实现

分类

无参无返回值

public static void 方法名(){}

调用：语法：方法名();

有参无返回值

public static void 方法名(数据类型参数名){}

调用：语法1：方法名(参数);
语法2：方法名(参数1,参数2,参数3);

有参无返回值

public static 数据类型方法名(){return 值;}

调用语法：数据类型变量名 = 方法名();

有参有返回值

public static 数据类型方法名(数据类型参数名){return 值;}

语法：数据类型变量名 = 方法名(参数1,....);

return关键字

作用

结束方法，并返回结果

有返回值的方法

必须要在方法中加入与返回值相同类型的值，return 值; 。如果有分支语
句，每个分支下都要有返回

没有返回值的方法

也可以使用return关键字，但是不能返回具体的值。此时return的作用是
结束方法

方法的注意事项

1. 一个方法有方法的定义+方法的实现组成

2、方法必须要写在类的里面，其他方法的外面

3、定义有返回值的方法，必须要有return。且一个方法只能有一个返回值

4、在调用有参数的方法的时候，实参的类型、个数、顺序要与形参保持一致

方法的好处

方法的作用就是为了实现某一个功能，为了减少代码的冗余。便于维护和修改
方法是单一职责，一个方法就做一件事情。是Java的设计原则之一为了降低耦合

方法的递归

定义

解决具有既定规律的问题时，在方法内部再次调用自身方法的一种编程方式

何时用

1、当需要解决的问题可以拆分成若干个小问题，大小问题的解决方式相同，方法中自己调用自己
2、使用循环解决的常规问题，都可以替换为递归解决

如何正确使用递归

设置有效的出口条件，可以让调用链上的每个方法都可以正确返回，避免无穷递归

数组

概念

在内存中一块连续的空间，用于存放相同数据类型的数据的一种容器

特点

数组中元素必须是相同的数据类型

数组是定长的（数组的长度一旦定义不能改变）

创建数组

动态初始化

语法：数据类型【】数组名=new 数据类型【数组长度】

静态初始化

语法：数据类型[] 数组名 = {元素1,元素2,元素3,....};
语法：数据类型数组名[] = {元素1,元素2,元素3,....};

数组的细节

数组中每一个数据称为元素

2、使用数组中元素通过数组名【下标】

3、数组下标范围 0~数组长度-1

4、数组的长度通过数组名.length获取

5、、数组的下标超过范围会报错（ArrayIndexOutOfBoundsException数组下标越界异常）

数组的遍历

通过循环获取数组中每一个元素

数组的默认值

整型：0

浮点型：0.0

字符型：空格

布尔型：false

引用型：null

数组的扩容

步骤

1、定义一个新数组

2、将原数组的内容拷贝到新数组

3、将数组名指向新数组的地址

方法

1、手动循环拷贝

2、System.arraycopy(原数组名, 原数组起始, 新数组名, 新数组起始，拷贝个数);

3、原数组名= Arrays.copyOf(原数组名,新数组的长度 );

数组排序

冒泡排序（升序）

用相邻的两个元素进行比较，如果前面一个元素比后面的大，就交换位置。此过程一轮操作,
会将最大值放到最后需要比较数组的长度-1轮，才能达到最终的排序结果

选择排序

每一轮选择一个位置，将当前这个位置上的数与后面的每一个数进行比较，如果有更小的
数，先记录下来，当这一轮结束后，将最小值与当前位置上的值进行交换

Arrays工具类排序方法

Arrays类中提供的 sort方法对数组进行排序
只能升序排列 Arrays.sort(数组名);
sort方法对字符串数组的排序规则是按照字典顺序(unicode码表的值)

数组查找

二分查找法（折半查找）

前提：数组中元素是有序的

思路:
首先找到数组中的中间的元素，与要查找元素进行比较，如果相等，那么就直接找到了
如果比中间的元素大，那么表示查找元素在中间值的右边。所以最小值的下标等于中间
值的下标+1
如果比中间的元素小，那么表示查找元素在中间值的左边。所以最大值的下标等于中间
值的下标-1

二维数组

与一维数组的区别

一维数组：一维数组中的每一个元素都是一个数据
二维数组：二维数组中的每一个元素都是一个一维数组

二维数组的创建

1、动态初始化
语法：数据类型[][] 数组名 = new 数据类型[ 二维数组的长度] [一维数组的长度];
注意：在创建二维数组的是，二维数组的长度是必须要指定的，而一维数组的长度暂时可以
不确定

2、静态初始化
语法：数据类型[][] 数组名 = {{元素1,元素2,..},{元素1,元素2,..},{元素1,元素2,..},.....};

二维数组的遍历

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

可变参数

语法

数据类型... 变量名

特点

1、如果方法中定义可变参数，那么在调用方的时候，实参的个数可以是0个或多个

2、可变参数在使用的是可以当做数组来使用

3、可变参数必须要放在方法的参数列表的最后一位(一个方法只能有一个可变参数)

4、可变参数的方法，调用的时候也可以直接传入一个数组

应用场景

当方法的参数不固定的时候，可以使用可变参数

可变参数方法的定义

public static void m1(int... a){
}

带有可变参数方法的调用

m1(1,2,3,4,5,6);

int[] arr = {2,3,4,5,6}; m1(1,arr);

值传递和引用传递

值传递

值传递，传递是值本身，所以对原来的变量没有影响

基本数据类型+String属于值传递

引用传递

传递的是地址，所以原来的数据有影响，它们指向的同一个地址中的内容

引用数据类型属于引用传递

面向对象

面向对象的思想

着重于对象

优点：耦合度低、易于扩展、易于维护

缺点：性能低

对象

定义：具有明确的行为（方法）和特征（属性）的实体

组成

行为

一般是动词，表示对象能干什么

特征（属性，实例变量)

一般是名词，表示对象有什么

对象的创建

语法：类名对象名 = new 类名();

类

类的创建

1、确定类名

2、编写成员变量

3、编写成员方法

定义

由多个具有相同特征和行为的对象抽取出来的

类与对象的关系

类是对象的模板，对象是类的实例

实例变量与局部变量的区别

1、定义的位置不同：局部变量定义在方法中，实例变量定义在类里面，方法外面

2、作用域不同：局部变量只能在定义的作用域中使用，就是所在{}内，实例变量在整个类中都可以使用

3、默认值不同：局部变量没有默认值，实例变量由默认值

4、生存周期不同：局部变量推出作用域就会被销毁，成员变量：对象被创建出现，对象被销毁时销毁

5、重名问题：局部变量：在不同的作用域可以重名，全局变量不能重名

方法的重载

定义

在一个类中出现同名方法称为方法的重载

要求

同名不同参（参数类型，个数，顺序）

与返回值，返回修饰符无关

好处

方便，灵活，屏蔽使用差异

构造方法

作用

类中的特殊方法，用于创建对象，给对象的属性赋值

语法

public 构造方法名（）{
}构造方法名必须与类名一致

特点

1、如果一个类没有编写构造方法，那么jvm会默认提供一个无参的构造方法，但如果一个类中提供了构造方法，那么jvm不会提供无参的构造方法

2、构造方法可以重载

3、一个类无论提供多少个构造方法，一定要保留一个无参构造方法

对象的创建过程

1、内存中开辟对象空间

2、为各个属性赋予初始值

this 关键字

含义

表示当前类的对象，在对象被创建时自动产生

作用

调用本类的属性

语法：this.属性名

调用本类的属性，this关键字可以省略

当前成员变量与局部变量重名的时候，this.属性名表示的是成员变量，不加this表示局
部变量(就近原则)

调用本类的方法

语法：this.方法名();

在本类中调用本类的方法this关键可以省略

调用本类的构造方法

语法：this(构造参数);

特点：
1、避免无穷递归(构造方法循环调用)
2、调用本类构造方法的时候，this(构造参数)必须写在构造方法的第一行

封装

必要性

在对象的外部，为对象的属性赋值，可能存在非法数据的录入。
就目前的技术而言，并没有办法对属性的赋值加以控制。

什么是封装

概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。
访问修饰符：private （可将属性修饰为私有，仅本类可见）

公共访问方法

提供公共访问方法，以保证数据的正常录入。

命名规范：
赋值：setXXX() //使用方法参数实现赋值
取值：getXXX() //使用方法返回值实现取值

过滤有效数据

在公共的访问方法内部，添加逻辑判断，进而过滤掉非法数据，以保证数据安全。

JavaBean 设计

分类

数据承载Bean

逻辑承载Bean

要求

1、一个JavaBean表示一个实体(实体类)

2、私有化所有属性，对外提供set、get、方法

3、提供有参、无参构造方法

继承

理解

生活中的继承

生活中的“继承”是施方的一种赠与，受方的一种获得。
将一方所拥有的东西给予另一方。

程序员的继承

程序中的继承，是类与类之间特征和行为的一种赠与或获得。
两个类之间的继承关系，必须满足“is a”的关系

父类的选择

功能越精细，重合点越多，越接近直接父类。
功能越粗略，重合点越少，越接近Object类。（万物皆对象的概念）

父类的抽象

实战：可根据程序需要使用到的多个具体类，进行共性抽取，进而定义父类。
在一组相同或类似的类中，抽取出共性的特征和行为，定义在父类中，实现重用

概念

类与类之间属性和方法的赠与和获得

作用

减少代码的冗余，提高代码的复用性。

语法

子类 extends 父类

特点

1、子类继承父类，子类可以拥有父类的属性和方法

2、子类继承父类，子类可以拥有自己独有的属性和方法

3、在java中一个子类只能拥有一个父类(单继承)，支持多重继承

4、在java中任何类都是直接或者间接继承自Object

不可继承

1、使用private修饰的私有属性和方法不能被继承

2、构造方法不能被继承

3、使用默认的修饰符，在不同包下不能被继承

方法的重写（覆盖）

为什么需要重写

当父类的方法不满足子类的需求时，需要对其进行重写

要求

方法的返回值类型，方法名，参数都要与父类中的方法保持一致

方法的权限访问修饰符要比父类该方法中的权限访问修饰符的范围要大或者相等

访问修饰符

子主题

方法的重写

含义

当子类从父类的继承的方法不能满足子类的需求时，在子类中可以对其进行重写

要求

方法名必须与从父类继承的方法名相同

参数列表必须与从父类继承的方法的参数列表相同

返回类型必须与从父类继承的方法的返回类型相同

访问权限并不能比父类中的方法更加严格

方法重写与方法的重载的不同

概念

方法重载：在一个类中可以定义多个方法名相同的方法
方法重写：在子类中对从父类中继承的方法进行改写

方法名

方法重载：多个方法的方法名相同
方法重写：子类的方法名与父类中的方法名相同

参数列表

方法重载：多个方法的参数列表不能相同
方法重写：子类方法参数列表必须与父类方法参数列表相同

返回类型

方法重载：无要求（可以同也可以不同）
方法重写：子类方法返回值必须与父类方法返回值相同

访问权限

方法重载：无要求
方法重写：子类方法访问权限不能比父类更加严格

super 关键字

在子类的使用super关键字表示父类

用法

1、在子类构造器中

在子类的构造器通过super调用父类的构造器

子主题

在子类的构造器中通过super关键字调用父类的方法

在子类的构造器中，会默认调用父类的无参构造器，如果父类的无参构造器不可达，则需要利用super关键字调用父类的其他构造器，如果不调用会抛出异常。

2、在子类方法中（注意不可调用父类的构造方法，构造方法只能在构造方法里面调用）

子主题

多态

什么是多态

一个父类的引用对象既可以表示一父类，也可以表示任何一个子类对象

应用场景

使用父类类型的变量作为方法的参数，在调用此方法时可以传递父类对象，也可以传递其中任何一个子类对象，可以增加代码的灵活性

注意

将子类对象隐式转换成父类的类型，还是子类的对象，但是只能调用从父类继承的方法和子类重写父类的方法，不能调用自己字自定义的方法,若要调用子类自定义的方法，需要强制类型转换。

abstract关键字

抽象方法

定义：只有方法的定义而没有方法的具体实现（方法体）

如何将一个方法定义成抽象方法

1、使用abstract关键字进行修饰

2、去掉方法的方法体（{})

抽象类

定义：用abstract修饰的类称为抽象类

特性

1、当一个类中存在抽象方法时，必须定义为抽象类

2、在抽象类中可以同时包含抽象方法和非抽象方法

3、当一个类中没有抽象方法时，这个类就没有定义为抽象类的必要

4、抽象类可以理解为一个不完整的类，抽象类的对象无法独立存在，因此不能直接用new创建对象

作用

1、为所有的子类提供一个公共的模板，要求继承当前抽象类的子类必须提供相同的属性和方法

2、将子类共有的属性定义在抽象类中，子类无需重复定义

3、可以声明父类的变量作为方法的返回值、参数，更合理的使用多态

子类继承抽象类的总结

子类为非抽象类

1、必须实现父类中所有的抽象方法（在子类中重写父类的方法——实现）

2、对于父类中的非抽象方法，子类可以重写也可不重写

3、如果子类中没有完全实现父类的抽象方法，那么子类需要定义为抽象类

子类是抽象类

1、对于父类中的抽象方法，子类可以不实现父类的任何方法

2、也可以部实现父类的抽象方法

static关键字

静态属性

含义：被static修饰的属性称为静态属性

特性

静态属性也称之为类属性，与类相关，在加载类时就在方法区分配静态属性变量的内存空间

静态属性可以通过类名.静态属性名直接调用

静态属性也可以通过对象调用，一个类中的所有对象都调用了同一个静态属性，但是通过某一个对象修改了这个静态属性的值，则其他对象访问的静态属性的值也被改变了

静态方法

静态方法可以通过`类名.静态方法`直接调用，也可以通过`对象.静态方法`调用

调用静态方法的可能是类，因此在静态方法中不能用this关键字

在静态方法中，不能直接使用非静态属性（可以通过对象使用）

在静态方法中给，不能直接调用非静态方法（可以通过对象调用）

静态代码块

匿名代码块

在类中可以直接用{}定义代码块

特性

匿名代码块不能被调用，但会在每次构造器执行之前执行

在一个类中可以定义多个匿名代码块，在每次构造器执行之前，按匿名代码块在类中的顺序在构造器执行之前执行

静态代码块

static{}

特性

静态代码块在类首次被加载时执行

在一个类中可以定义多个静态代码块，在类首次加载的时候按照定义的顺序依次执行

final关键字

定义常量

修饰类中的属性，表示属性的值不能修改，为常量

定义不可重写的方法

修饰方法，表示此方法可以被子类继承，但是不允许子类重写该方法

定义不可被继承的类

修饰类，表示该类为最终类，不能被继承

接口

为什么要用接口

Java中的继承是单继承，我们不能让一个子类同时继承多个父类，接口的存在就弥补了单继承的不足，接口可以多实现

定义

相当一特殊的抽象类，在定义方式、组成部分和抽象类相同，但存在差异

语法

public interface <InterfaceName>{
//
}

接口与抽象类的不同

1、抽象类中可以定义抽象方法和非抽象方法，但接口只能定义抽象方法

2、定义在接口中的抽象方法可以省略abstract关键字

3、一个子类只能继承一个抽象类，一个实现类可以同时实现多个接口

接口与抽象类的区别

语法

接口：public `abstract class` AbsClassName{}

抽象类：public `interface` InterfaceName{}

元素

抽象类：变量，常量，抽象方法，非抽象方法

接口：常量（公开public），抽象方法，接口默认方法

继承与实现

抽象类：单继承extends

接口：多实现implements

类的继承与接口实现

抽象类	接口	非抽象类
抽象类	extends	implements（多）	extends
接口	——	extends（多）	——
非抽象类	extends	implements（多）	extends

接口的应用

1、定义规范

要求所有能够传递的此方法的对象，必须实现接口

2、定义模板

3、定义常量列表

public static final String BLUE="#0000FF"

内部类

定义：定义在类或者方法中的类

分类

成员内部类

定义：定义在类中的内部类

被static修饰的成员内部类称之为静态成员内部类

如何创建对象

创建非静态内部类的对象(需要通过外部类的对象调用构造器）

ClassA.ClassB b=a.new ClassB()

创建静态内部类的对象（直接通过外部类的类名调用构造器）

ClassA.ClassC c=new ClassA.ClassC()

局部内部类

定义：定义在方法中的内部类

匿名内部类

与普通类的区别

内部类是定义在类中或方法中的类，相当于类中的成员

普通（外部）类不能使用private或者protected进行修饰，但是内部类作为类的成员可以使用任意访问权限修饰符

普通（外部）类不能是同static 修饰，但是内部类可以使用static定义成静态内部类

普通（外部）类可以直接使用，但是内部类必须通过外部类来调用

 收藏

立即使用

JAVA

chloe

职业：暂无

去主页





0 条评论

下一页

为你推荐

查看更多



JAVA

java