java基础

最新推荐文章于 2024-07-19 17:37:28 发布

超白小白

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量770

点赞数 1

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_52904146/article/details/115478718

版权

Java基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

JAVA基础

基础语法：
数据类型/基本类型/运算符/流程控制/数组
面向对象：
概念/封装/继承/多态/抽象类/final/static/访问控制符/
对象创建流程/接口/内部类
基础API：
Object/String/StringBuilder/StringBuffer/正则表达式
/Integer/BigDecimal/BigInteger/Date
集合:
ArryList/LinkedList/HashMap/LinkHashMap/
ConcurrentHashMap/ConcurrentHashSet
异常：
出BUG解决BUG是我们程序员的宿命
IO：
File/InputStream/OutputStream/FileIO/ObjectIO/
序列化/Reader/Writer/IputStreamReader/
OutputStreamWriter/BufferedReader/PrintWriter/
PrintStream
线程：
创建/方法/同步/生产者/消费者/等待和通知
网络：
Socket/ServerSocket
反射：
获得类的对象/创建对象/注解

Java语言特性

简单性高性能编译性解释性分布式处理健壮性安全性
面向对象开源跨平台
什么是跨平台？
通过java语言编写的应用程序在不同的系统平台上都可以运行
跨平台的原理：
不同的操作系统有与之对应的JVM，只需要在需要运行Java应用程序的操作系统上，安装一个JVM，由JVM来负责Java程序在该系统中的运行。所以只需要写一个Java程序就可以在多个不同的操作系统上执行。也被称之为Java具有良好的可移植性。
注意： JVM是Java语言能够跨平台的前提，但是JVM本身不跨平台

JDK

JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。
JDK是整个java开发的核心,它包含了:

```
 JAVA开发工具(jdk\bin)
```
```
 基础开发库(jdk\jre\lib\rt.jar)
```
```
 基础开发库的源码(jdk\src.zip)
```

环境变量的配置：
选择“我的电脑”–>“属性”–>“高级系统设置”–>“环境变量”按钮，打开环境变量配置对话框

开发

编译期：
.java源文件经过编译生成.class字节码文件
运行期：
JVM加载.class字节码文件并运行
跨平台：
java源代码.java文件编译–>字节码.class文件不同系统上安装对应的JVM，不同的JVM运行Java程序，也就实现了跨平台

打印"HelloWorld"

package cn.tedu.hello;
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“hello world~”);
System.out.print(“hello world~”);
}
}

标识符

标识符可以简单的理解成一个名字。在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符，一个正确的标识符需要遵循以下规则：

标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符
2 . 不能以数字开头。如：123name 就是不合法
3 . 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
标识符的命名最好能反映出其作用，做到见名知意。
标识符不能是Java的关键字

关键字

在Java中有一些单词被赋予了特定的意义，一共有50个关键字，这50个关键字全都是小写，其中有两个关键字被保留：const和goto
**注意：**关键字不能被用作为标识符！
abstract char else for interface private super transient
boolean class extends if long protected switch true
break continue false implements native public synchronized try byte default final import new return
this void case do finally instanceof null short throw
volatile catch double float int package static thows while

注解

几乎所有编程语言都允许程序员在代码中输入注释,因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
注释的真正作用是：它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息，提高代码的可读性,方便后期的维护与复用。Java的注释有3种:

```
 	单行注释: 注释单行内容.  
```
```
 	格式: 每行都以”//”开头.
```

 	多行注释：注释多行内容,虽然叫多行注释,也可注释单行内容.
 	格式: 以”/*”开头， 以”*/”结束

   文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.
 	格式: 以”/**”开头。 以”*/”结尾.

变量

在JAVA中，我们需要记录一些数据,但这些数据的值是不固定的，总在变，我们可以把这些数据理解为变量。
我们通过三个元素来描述变量：变量类型变量名以及变量值。
注意：

 变量名必须是一个有效的标识符

```
 变量名不可以使用java关键字
```
```
 变量名不能重复
```

数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
java是一个强类型的语言,会把日常见到的数据,分成好多类型.
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
位 bit，来自英文bit，音译为“比特”，表示二进制位。
1 Byte = 8 Bits (1字节 = 8位)
1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB

整数型：
类型名称
byte 字节空间 1 取值范围-27到27-1 或者 -128到127
short 字节空间 2 取值范围 -215到215-1
int 字节空间 4 取值范围 -231到231-1
long 字节空间 8 取值范围 -263到263-1
浮点型：
类型名称
float 字节空间 4 取值范围单精度,对小数部分的精度要求不高
double 字节空间 8 取值范围双精度，精确的小数部分并操作值很大时
字符型：
类型名称
char 字节空间 2取值范围0到65535
布尔类型：
类型名称
boolean 字节空间 1取值范围真true 假false
变量基本类型
局部变量
位置:定义在方法里或者局部代码块中
注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
作用域:也就是方法里或者局部代码块中,方法运行完内存就释放了
成员变量
位置:定义在类里方法外
注意:不用初始化,也会自动被初始化成默认值
作用域:整个类中,类消失了,变量才会释放

查看基本类型的最大值与最小值

最大值：.MAX_VALUE;
最小值：.MIN_VALUE;

变量交换

引用类型

引用类型是一个对象类型,它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。如：类，接口，数组。

基本类型的字面值

**1. 整数字面值是int类型

byte,short,char,三种比int小的整数可以用范围内的值直接赋值
浮点数的字面值是double
进制前缀：**
0b - 表示这是2进制
0 - 表示这是8进制
0x - 表示这是16进制
\u - 表示这是一个char类型,属于16进制

基本类型的类型转换

基本类型的类型转换
箭头开始的地方是小类型,箭头指向的地方是大类型
小转大(隐式转换)

byte m = 120;  
int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
float  f = 3.2f; double d = f; //-->可以执行

大转小(显示转换)
需要强制类型转换

int x = 999;
byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换

容量大的类型转换为容量小的类型时必须使用强制类型转换

转换过程中可能导致溢出或损失精准度
浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入
不能对boolean类型进行类型转换

运算规则

计算结果的数据类型与最大类型保持一致
int/int–得到的结果是int
int/double–得到的结果是double
byte,short,char三种比int小的整数运算时会先自动转换为int

  byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);
    //a+b会自动提升成int类型，右面得运算结果就是int大类型
    //给左面的byte小类型赋值，不可以，需要强转。

**整数运算的溢出**
**整数运算,类似于一个钟表,转到最大时,再转会回到最小**
计算：光速运行一年的长度是多少米？3亿m/s

//溢出的现象：
//因为做了大的整型数据的运算，会超出int取值范围。解决方法：把整数提升成long类型。
System.out.println(300000000L606024365);
浮点数运算不精确
浮点数的特殊值
Infinity 无穷大 3.14/0
NaN not a number 0/0.0 或 0.0/0

ASCII编码表

ASCII(American Standard Code for Information Interchange)编码表，美国标准信息交换代码。
在计算机中，所有的数据在存储和运算时都要使用二进制数表示。
a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则。
于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。
中国 gb2312【字少】 àgbk【识别4万+汉字】à万国码表unicode【ISO制定】
所有码表都兼容ASCALL
ASCII编码表

运算符

概述:
运算符用于连接表达式的操作数,并对操作数执行运算
在JAVA语言中,运算符可以分为5种类型:
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符
根据操作数的不同,运算符又分为单目运算符、双目运算符、三目运算符
运算符表格图

算术运算符之自增自减运算符
a是操作数,++是自增运算符,–是自减运算符，自增和自减运算符即可以放在变量的前面也可以放在变量的后面,例如a++、++a、a–、--a
自增（++）：将变量的值加1
分前缀式（如++a）和后缀式（如a++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（–）：将变量的值减1
分前缀式（如–a）和后缀式（如a–）。前缀式是先减1再使用；后缀式是先使用再减1。
逻辑运算符
逻辑运算符连接两个关系表达式或布尔变量，用于解决多个关系表达式的组合判断问题
注意逻辑运算符返回的运算结果为布尔类型
通常，我们用0表示false，用1表示true
与：表示并且的关系
单与&： 1 & 2 ，结果想要是true，要求1和2都必须是true
双与/短路与&&：1 && 2 ，当1是false时，2会被短路，提高程序的效率
或：表示或者的关系
单或|： 1 | 2，结果想要是true，要求1和2只要有一个为true就可以
双或/短路或||：1 || 2，当1是true时，2会被短路，提高程序效率

分支结构

概述
顺序结构的程序虽然解决计算、输出等问题但是不能做出判断再选择，对于要先做出判断的问题要使用分支结构
当判断条件成立时(返回true)，才会执行代码…

  单分支
        if(判断条件){ 代码 }
    多分支
    if(判断条件){
      // 代码1
    }else{
     //  执行不满足条件的代码2
    }
    嵌套分支
    if(判断条件1){
     //  代码1
    }else if(判断条件2){
       //执行不满足条件的代码2
    }else if(判断条件3){
      // 执行不满足条件的代码3
    }else{
      // 执行谁都不满足条件的代码4
    }

switch结构

概述:
switch case 语句用来判断一个变量与一系列值中某个值是否相等,每个值成为一个分支,当一个case成立，从这个case向后穿透所有case,包括default,知道程序结束或者遇到break程序才能停止
形式

switch(expression){
    case value : syso(1)//语句 break; //可选
    case value : syso(2)//语句 break; //可选
    case value : syso(3)//语句 break; //可选
    case value : syso(4)//语句 break; //可选
    //可以有任意数量的case语句
    default : syso(0)//语句//可选 //语句
}

switch结构的注意事项

switch 语句中变量类型可以是:byte、short、int、char、String(jdk1.5以后支持)
switch 语句可以拥有多个 case 语句
每个 case 后面跟一个要比较的值和冒号,且此值的数据类型必须与变量的数据类型一致
当变量值与 case 语句值相等时，开始执行此case 语句的内容,执行完会判断此行代码是否有break,如果有,结束执行,如果没有,会继续向后执行穿透所有case,包括default
switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句
如果在default之前的case有break,则default不会执行

循环结构

for循环概述
循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。
for形式

for(开始条件;循环条件;更改条件){
    syso循环体;
}

for循环执行顺序:
开始条件–>循环条件–>循环体–>更改条件–>循环条件–>循环体–>更改条件

嵌套for循环

嵌套for循环概述
存在至少2层for循环,根据外层的条件，判断里层能否执行。如果能执行，就把里层代码都循环完毕后，再继续判断是否执行外层循环的下一次循环
嵌套for循环形式

for(开始条件;循环条件;更改条件){ //外层循环
    for(开始条件;循环条件;更改条件){ //内层循环
			循环体;
	}
}

break与continue

break: 直接结束当前循环,跳出循环体,简单粗暴
break以后的循环体中的语句不会继续执行,循环体外的会执行

continue: 跳出本轮循环,继续下一轮循环
continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

形式

for(){
代码1
if(条件){
       代码3…
       break;//如果成立，直接跳出这个for循环
}
代码2…
}
continue：跳出本次循环，进入下一轮
for(){
   代码1
if(条件){
        代码3…
        continue;//如果成立，跳出本次for循环，进入下一轮
}
代码2…
}

while循环

形式:
先判断,再执行

while(执行条件){
循环体;
}

do-while循环

形式
先执行,再判断,循环体代码保证最少执行一次

do{
循环体;
} while (执行条件);

数组

概念
数组Array，标志是[ ]，用于存储多个相同类型数据的集合，想要获取数组中的元素值，可以通过下标来获取，数组下标是从0开始的，下表的最大值是数组长度-1
创建数组
数组的创建方式一般分为动态初始化和静态初始化

//1. 动态初始化
        int[] a = new int[5];
//2. 静态初始化
        int[] b = new int[]{1,2,3,4,5};
        int[] c = {1,2,3,4,5};

数组工具类Arrays

Arrays.toString(数组)
把数组里的数据,用逗号连接成一个字符串[值1,值2]
Arrays.sort(数组)
对数组进行排序,对基本类型的数组使用的是优化后的快速排序算法,效率高对引用类型的数组,使用的是优化后的合并排序算法
Arrays.CopyOf(数组,新的长度)
把数组赋值成为一个指定长度的新数组,
新数组的长度大于原数组相当于复制并增加位置
新数组的长度小于原数组相当于截取一部分数据

二维数组

概念
存放数组的数组,也就是说数组里存放的还是数组数据形式

创建二维数组

int[][] a = {{3,5},{7,9},{1,2}};
//--创建外部数组,长度是3
//--给每个外部数组的位置创建内部数组,每个内部数组的长度是2
//--给每个内部数组进行数据初始化
//--二维数组生成唯一的地址值
//--把地址值交给引用类型变量a来保存

遍历二维数组

for (int i = 0; i < a.length; i++) {//遍历外部数组
            for (int j = 0; j < a[i].length; j++) {//遍历内部数组
                System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
            }
        }

冒泡排序bubble

概念
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
形式
相邻比较，从小到大排序，如果小就往前换

面向对象

概念
面向对象其实是一种编程思想,通过它可以把生活中复杂的事情变得简单,从原来的执行者变成了指挥者。
面向对象是基于面向过程而言的
面向对象的三大特征:

封装性,把相关的数据封装成一个"类"组件
继承性,是子类自动共享父类属性和方法,这是类之间的一种关系
多态,增强软件的灵活性和重用性

类和对象

类

Java语言最基本单位就是类，类似于类型。
类是一类事物的抽象。
可以理解为模板或者设计图纸。
对象
每个对象具有三个特点：对象的状态，对象的行为和对象的标识。
对象的状态用来描述对象的基本特征。
对象的行为用来描述对象的功能。
对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
类是一类事物的抽象，对象是具体的实现。
类和对象的关系
计算机语言来怎么描述现实世界中的事物的? 属性 + 行为
那怎么通过java语言来描述呢?通过类来描述一类事物,把事物的属性当做成员变量,把行为当做方法
对象在内存中的存储
Java把内存分成5大区域，我们重点关注栈和堆。
一般来讲局部变量存在栈中，方法执行完毕内存就被释放
对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
每个堆内存的元素都有地址值
对象中的属性都是有默认值的
栈与队列指的是一种数据的结构。
栈：先进后出（FILO – First In Last Out）
队列：先进先出（FIFO – First In First Out）

封装

概述
封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
好处:

提高安全性
提高重用性
private关键字
修饰符,可以用来修饰成员变量和成员方法,被私有化的成员只能在本类中访问

如何封装?封装后的资源如何访问?
我们可以使用private关键字来封装成员变量与方法
如何访问私有资源?
关于成员变量:

setXxx – 对外提供公共的设置值方式
getXxx – 对外提供公共的获取值方式
关于成员方法:
把私有方法放在公共方法里供外界调用即可
例子：

public static void main(String[] args) {
Teacher t = new Teacher();//6.调用无参构造创建对象
//7.由于private将Teacher类中的属性都封装了,外界无法直接使用,所以需要使用set()/get()
//t.name;//报错:The field Teacher.name is not visible
System.out.println(t.getName());//如果没有设置值或者是设置没有成功，获取的是默认值null
t.setName("鲁智深");
System.out.println(t.getName());
//8.直接调用全参构造来创建对象并且给对象的属性赋值
Teacher t2 = new Teacher("李逵","壮汉",28,300);
System.out.println(t2.getName()+t2.getAge()+t2.getGender()+t2.getSalary());
}
}
//1.创建Teacher类
class Teacher{/**1.属性  2.get()/set() 3.构造方法*/
//2.1提供属性
//2.2对属性进行封装--通过private关键字进行封装
private String name;
private String gender;
private int age;
private double salary;
/**如果什么构造方法都没有添加,默认会存在无参构造
 * 我们创建了丰富的构造方法,是为了给外界提供创建本类对象的多种方式
 * 如果自定了含参构造,默认的无参构造会被覆盖,注意手动添加哦
 * */
//3.添加无参构造方法
public Teacher() {
System.out.println("我是无参构造");
}
//4.添加全参构造方法
public Teacher(String n,String g,int a,double s) {
//5.在构造方法中为成员变量进行赋值
name = n;//n是局部变量也就是用户调用此构造传入的参数,把参数赋值给成员变量name
gender = g;
age = a;
salary = s;
System.out.println("我是全参构造");
}
//2.3需要给外界提供公共的属性设置与访问方式
//快捷方法:右键空白处-->Source-->Genreate Getters and Setters-->select All-->Generate生成即可
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}

创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情

```
把Person.class文件加载进内存
```

在栈内存中，开辟空间，存放引用变量p

在堆内存中，开辟空间，存放Person对象

对成员变量进行默认的初始化

```
对成员变量进行显示初始化
```

执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）

```
堆内存完成
```

把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值

匿名对象

没有名字的对象,是对象的简化表示形式
**使用场景:**当被调用的对象只调用一次时(多次会创建多个对象浪费内存)

面向对象2

构造方法
概念
构造方法是一种特殊的方法,它是与类同名切没有返回值类型的方法,对象创建就是通过构造方法完成的,主要功能是完成对象的创建或者对象的初始化,当类创建对象(实例化)时会自动调用构造方法,构造方法与普通方法一样可以被重载
形式
与类同名,且没有返回值类型,可以含参也可以不含参
修饰符方法名([参数列表]){ 注意:方法名与类名一样
代码……
}
特点
方法名与类名相同,且没有返回值类型
执行时机:
创建对象时立即执行
默认会创建无参构造,但是,如果自定了含参构造,默认的无参构造会被覆盖,注意要手动添加

变量

概念
可以改变的数,称为变量，在java语言中,所有的变量在使用前必须声明。
一般通过“变量类型变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
变量的使用原则：就近原则,即尽量控制变量的使用范围到最小
局部变量
位置: 定义在方法里或者局部代码块中
注意: 必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
作用域: 也就是方法里或者局部代码块中,方法运行完内存就释放了
成员变量
位置: 定义在类里方法外
注意: 不用初始化,也会自动被初始化成默认值
作用域: 整个类中,类消失了,变量才会释放

构造代码块与局部代码块

{代码…}
构造代码块的特点

位置：在类的内部,在方法的外部
作用：用于抽取构造方法中的共性代码
执行时机：每次调用构造方法前都会调用构造代码块
注意事项：构造代码块优先于构造方法加载
局部代码块
位置：在方法里的代码块
作用：通常用于控制变量的作用范围,出了花括号就失效
注意事项：变量的作用范围越小越好,成员变量会存在线程安全问题

this

概念
This代表本类对象的一个引用
例如：this.name=name;

继承

概念
集合呢个是面向对象最显著的一个特征,继承是从已有的类中派生出新的类,新的类能吸收已有的类的数据属性和行为,并拓展新的能力,java继承是会用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或者新的功能,
也可以使用父类的功能,但不能要选择继承父类(超类/基类)
这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用
特点

使用关键字extends来表示父类的继承
相当于子类把父类中的功能复制了一份
java只支持单继承
继承可以传递
不能继承父类的私有成员
继承多用于功能的修改,子类可以在拥有父类功能的同时进行功能拓展

super

可以通过这个关键字使用父类的内容,super代表的是父类的一个引用对象
**注意：**在构造方法里,出现的调用位置必须是第一行

方法重写Override

继承以后,子类就拥有了父类的功能
在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
格式要求:方法的返回值方法名参数列表要完全一致,就方法体是重写的
父类的私有方法不能被重写,子类在重写父类方法时,修饰符
子类重写父类方法时,子类修饰符要大于等于父类修饰符的权限

this与super的区别

This代表本类对象的引用
class Father3{ this.XXX } //this – Father3 this = new Father3();
super代表父类对象的引用
class Father3{ super.XXX } //this – Father3 super = new Father3();
就相当于创建了一个父类对象
this可以在两个变量名相同时,用于区分成员变量和局部变量
this 可以在本类的构造方法之间调用,位置必须是第一条语句,注意,不能相互调用,会死循环
super是发生了继承关系以后,子类如果想用父类的功能,可以通过super调用
如果发生了重写,还想用父类的功能,需要使用super来调用
Super在调用父类构造方法时,必须出现在子类构造方法的第一条语句,而且如果父类中没有提供无参构造,子类可以通过super来调用父类其他的含参构造

重载Overload 与重写Override的区别

重载: 是指在一个类中的现象,是指一个类中有很多同名的方法,但是方法的参数列表不同
重写: 是指发生了继承关系以后(两个类),子类去修改父类原有的功能,子类中有一个方法签名(返回值类型方法名(参数列表) )和父类的一模一样
重载的意义: 是为了方便外界对方法进行调用,什么样的参数程序都可以找到对应的方法来执行,体现的是程序的灵活性
重写的意义:是在不修改源码的前提下,进行功能的修改和拓展
(OCP原则:面向修改关闭,面向拓展开放)
重写要求方法的修饰符: 子类权限 >= 父类的权限

向上转型与向下转型

static

概念
static是java中的一个关键字,用于修饰成员变量和成员方法
特点

可以修饰成员变量与成员方法
随着类的加载而加载,会优先于对象加载
只加载一次,就会一直存在,不再开辟新的空单建,直到类消失才一起消失
静态资源也叫做类资源,全局唯一被全局所有的对象共享
可以直接被类型调用
静态只能调用静态,非静态可以随意调用
static不能和this和super一起使用,因为有static时可能还没有对象
附上一手堆栈图

静态代码块、构造代码块、局部代码块

静态代码块
static{ }
静态资源随着类的加载而加载,并且只被加载一次,一般用于项目的初始化
特点
被static修饰,位置在类里方法外
三种代码块的区别

静态代码块：在类的加载时就加载,并且只加载一次,一般用于项目的初始化
构造代码块：在创建对象时会自动调用,每次创建对象都会被调用,提取构造共性
局部代码块：方法里的代码块,限制局部变量的范围
**执行顺序:**静态代码块 --> 构造代码块 --> 构造方法 --> 局部代码块

多态

概念
多态是指同一个实体具有多种形式
它主要是面相对象程序设计(OOP)的一个重要的特征
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处：可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
特点

多态的前提1：是继承
多态的前提2：要有方法的重写
父类引用指向子类对象,如：Animal a = new Cat();
多态中，编译看左边，运行看右边

多态的好处：
多态可以让我们不用关心某个对象到底具体是什么类型就可以使用该对象的某些方法
提高了程序的可拓展性和可维护性

多态的使用

特点

成员变量: 使用的是父类的
成员方法: 由于存在重写现象,所以使用的是子类的
静态成员: 随着类的加载而加载,谁调用就返回谁的

静态变量和实例变量的区别

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
向上转型和向下转型
在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
在应用中就存在着两种转型方式，分别是：向上转型和向下转型。
比如：父类Parent,子类Child
向上转型：父类的引用指向子类对象Parent p=new Child();
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的
说明向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。

异常

用来封装错误信息的对象
组成结构:类型提示行号
TIPS: Ctrl + Shift + T :在eclipse当中查找你想找到的类
Ctrl + T : 查看类的继承结构
Ctrl + O : 查看类的结构信息(大纲)
异常的继承结构
Throwable : 顶级父类
–Error : 系统错误,无法修复
–Exception : 可以修复的错误
– RunTimeException
– ClassCastException
– ClassNotFoundException
– …
异常处理

//当程序中遇到了异常,通常有两种处理方式:捕获或者向上抛出
//当一个方法抛出异常,调用位置可以不做处理继续向上抛出,也可以捕获处理异常
//1) 捕获方式：
try{
//需要捕获的代码
}catch(异常类型  异常名){
//处理方案
}
//2) 抛出方式：
//在会发生异常的方法上添加代码：throws 异常类型
//例如：public static void main(String[] args)  throws Exception{

访问控制符

**用来控制一个类,活着累中成员的方位范围
访问控制符
**注意：**default是表示不写修饰符,默认,如果写default单词来修饰会报错

抽象类

Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.
Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类
如果一个类含有抽象方法,那么它一定是抽象类，抽象类中的方法实现交给子类来完成
抽象方法的格式
权限修饰符 abstract 返回值类型方法名(参数列表);
特点

abstract 可以修饰方法或者类
被abstarct修饰的类叫做抽象类,被abstract修饰的方法叫做抽象方法
抽象类中可以没有抽象方法
如果类中有抽象方法,那么该类必须定义为一个抽象类
子类继承了抽象类以后,要么还是一个抽象类,要么就把所有抽象方法都重写
多用于多态中
抽象类不可以被实例化
抽象类中可以有普通方法吗?–可以!!
抽象类中可以都是普通方法吗?–可以
抽象类中可以有抽象方法,一旦类中有抽象方法,这个类就必须被声明成抽象类
如果一个类中都是普通方法,这个类为什么还要被声明成抽象类呢?
原因:抽象类不可以创建对象,如果不想让外界创建本类的对象,可以把普通类声明成一个抽象类
抽象类中可以有成员常量吗?–可以有,但是值无法修改
抽象类中可以有成员变量吗?–可以!
当一个类继承了父类,父类是一个抽象类时子类需要重写抽象父类中的所有抽象方法,如果不重写,就需要把自己变成一个抽象子类

接口

abstract class Animal{
abstract public void eat();
abstract public void sleep(){
}
class Dog extends Animal{
eat(){...}
}
class Cat extends Animal{
eat(){...}
}
class Pig extends Animal{
eat(){...}
}

概念
Java里面由于不允许多重继承,所以如果要实现多个类的功能,则可以通过实现多个接口来实现,Java接口和Java抽象类代表的就是抽象类型,就是我们需要提出的抽象层的具体表现
OOP面向对象编程,如果要提高程序的复用率,增加程序的可维护性,可扩展性,就必须是面向接口编程,面向抽象的变成,正确的使用接口/抽象类这些抽象类型作为java结构层次上的顶层.
接口格式
interface 接口名{ 代码… }
特点

接口中都是抽象方法
通过interface关键字来定义接口
通过implements让子类来实现接口
可以理解成,接口是一个特殊的抽象类(接口里的方法都是抽象方法)
接口突破了java单继承的局限性
接口和类之间可以多实现,接口与接口之间可以多继承
接口是对外暴露的规则,是一套开发规范
接口提高了程序的功能拓展,降低了耦合性
注意各位，接口中可以有普通方法，在几版本后我忘了…加上静态static是可以有的
接口之构造方法
接口里是没有构造方法的。在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。
子类创建对象时,会自动调用父类的构造方法,但是现在的父级是个接口接口里没有构造方法,那子类中super()调用的是什么呢?
结论:子类默认继承了顶级父类Obejct,super()会自动调用Object的无参构造
接口之成员变量
接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final
接口中的变量实际上都是静态常量,可以通过类名直接调用
接口中的变量实际上都是静态常量,不能被重新赋值
接口之成员方法
接口中的方法都是默认为抽象的，如果不写明写abstract那会自动补齐

接口总结1.类与类的关系

–继承关系,只支持单继承
–比如,A是子类 B是父类,A具备B所有的功能(除了父类的私有资源)
–子类如果要修改原有功能,需要重写(方法签名与父类一致 + 权限修饰符>=父类修饰符)
类和接口的关系
–实现关系.可以单实现,也可以多实现
–class A implements B,C{}
–其中A是实现类,B和C是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类
接口与接口的关系
–是继承关系,可以单继承,也可以多继承
–interface A extends B,C{}
–其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)
–class X implements A{}
–X实现类需要重写ABC接口的所有方法,否则就是抽象类
–class A extends B implements C,D{}
–其中A是实现类,也是B的子类,同时拥有CD接口的所有功能
–这时A需要重写CD接口里的所有抽象方法
抽象类与接口的区别
–抽象类是一个特殊的类,特殊在,抽象类中可以包含没有方法体的方法(抽象方法)
–接口可以理解成一个特殊的抽象类,特殊在,接口里的都是抽象方法,没有普通方法
–接口会为方法自动拼接public abstract,还会为变量自动拼接public final static
–抽象类可以有构造方法–用来给子类创建对象,接口中没有构造方法
–抽象类和接口都不能实例化(创建对象)
–抽象类可以有普通方法,接口都是抽象方法
abstract注意事项
抽象方法要求子类继承后必须重写。那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。

private：被私有化后，子类无法重写，与abstract相违背。
static：静态优先于对象存在。而abstract是对象间的关系，存在加载顺序问题。
final：被final修饰后，无法重写，与abstract相违背。
接口和抽象类的区别
抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
抽象类要被子类继承，接口要被类实现。
接口只能做方法声明，抽象类中可以做方法声明，也可以做方法实现
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
抽象方法只能声明，不能实现，接口是设计的结果，抽象类是重构的结果
抽象类里可以没有抽象方法
如果一个类里有抽象方法，那么这个类只能是抽象类
抽象方法要被实现，所以不能是静态的，也不能是私有的。
接口可继承接口，并可多继承接口，但类只能单继承

了解软件设计的开闭原则OCP

开放功能扩展，关闭源码修改。等开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统。
开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。
开闭原则，是一种设计模式，随着面向对象程序设计的思想，应运而生。
开，指的是可以在源代码的基础上进行扩展，比如继承，接口，抽象类等。在JAVA中，之所以用继承，是在可以直接调用类库的前提下，对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发。
闭：指不允许对原有的代码进行修改。以免影响其他现有功能，造成功能瘫痪。

API

概念
API（Application Programming Interface，应用程序接口）是一些预先定义的函数。目的是提供应用程序与开发人员基于某软件可以访问的一些功能集，但又无需访问源码或理解内部工作机制的细节.
API是一种通用功能集,有时公司会将API作为其公共开放系统,也就是公司制定自己的系统接口标准,当需要进行系统整合,自定义和程序应用等操作时,公司所有成员都可以通过该接口标准调用源代码.

Object

概念
Object类是所有Java类的祖先,也就是说我们所说的”顶级父类”。
存在于java.lang.Object,这个包不需要我们手动导包，每个类都使用Object作为超类.所有对象(包括数组)都实现这个类的方法.在不明确给出超类的情况下,Java会自动把Object类作为要定义类的超类.
常用方法
toString() 本方法用于返回对应对象的字符串表示
hashCode() 本方法用于返回对应对象的哈希码值
哈希码是一种算法,使不同的对象有不同的哈希码值,但是也有相同的情况,我们称之为”哈希碰撞”
equals() 本方法用于指示其他某个对象是否与当前对象“相等”

String

特点
String是一个封装char[]数组的对象,字符串不可变
被final修饰,是常量
String str = “abc”; 等效于:char data[] = {‘a’, ‘b’, ‘c’};
创建String对象的方式
方式一
String(char[ ] value)分配一个新的String,使其表示字符数组参数中当前包含的字符序列.
方式二
String str = “abc”;

如果是第一次使用字符串,java会在字符串常量池创建一个对象
再次使用相同的内容时,会直接访问常量池中存在的对象
常见方法

length()-查看字符串的长度
charAt()-定位某个字符,返回它的位置
lastIndexOf()-某个字符最后一次出现的位置
substring()-截取子串,如果参数有两个左闭右开[1,5)
equals()-判断两个串是否相等,注意String重写了Object的此方法,所以内容相同就返回true
startsWith()-判断是不是以参数开头
endsWith()-判断是不是以参数结尾
split()-以指定字符分割
trim()-去掉首尾两端的空格
getBytes()-把串转成数组
toUpperCase()-变成全大写
toLowerCase()-变成全小写
String.valueOf(10)-把int类型的10转换成String类型

StringBuilder/StringBuffer

特点

封装了char[]数组
是可变的字符序列
提供了一组可以对字符内容修改的方法
常用append()来替代字符串做字符串连接+
内部字符数组默认初始容量为16:super(str.length()+16)
如果大于16会尝试将扩容,新数组大小变为原来的2倍+2,容量如果还不够,直接扩充到需要的容量大小。int newCapacity = value.length*2+2;
StringBuffer 1.0出道,线程安全,StringBuilder 1.5出道,线程不安全