java基础

计算机硬件和软件(冯诺依曼体系结构：输入输出，存储，计算器，控制器)

计算机软件分为系统软件(DOS、Windows,Linux）和应用软件(WPS,QQ)

DOS命令

1.打开CMD命令

1. 开始-系统-命令提示符

2. win+R，输出cmd打开控制台

3. 在任意的文件夹下面，按照shift+鼠标右键点击，在此处打开命令行窗口

常用的命令

#盘符切换
# 查看当前目录下的所有文件 
dir
#切换目录
cd .. 返回上一级
cd {目录名字}
#清理屏幕 cls
#退出终端 exit
#查看电脑的IP ipconfig
#打开应用 calc\mspaint,notepad
#ping命令
ping www.baidu.com
#目录和文件操作（/d是切换盘符操作）
cd /d C:\user\ 
md test 创建目录
cd test
cd>a.txt 创建文件
del a.txt 文件名
cd ..
rd test 目录名

JAVA特性

简单性

面向对象，可移植性，

java注释

单行注释、多行注释、文档注释

1. //

2. /* XXX */

3. /**

*XX

*XX

**/

标识符和关键字

Java所有的组成部分都需要名字，标识符：类名、变量名、方法名都被成为标识符

注意点：

所有标识符都以字母大（A-Z）小（a-z）写，美元符（$）或者下划线开始

首字符以后可以是任意字母或者数字

不能使用关键字作为变量名或者方法名

大小写敏感

数据类型

强类型语言：要求变量的使用严格符合规定，所有变量都必须先定义后使用

类型转换：byte,short,char->int ->long->float->double

强制转换；从高到低

自动转换：从低到高

注：转换的时候会存在内存溢出，精度转换

弱类型语言

Java基本类型：基本类型和引用类型

1.基本类型：

1.1 数值类型

• 整数型：byte,short,int ,long(数字后面加L)

• 浮点类型:float(数字后面加F)，double

• 字符类型：char(String是字符串不是关键字，它是类)

1.2 boolean类型：true或者false

2.引用类型

• 类

• 接口

• 数组

注意点:不要使用浮点数比较

所有的字符本质还是数字（编码 Unicode 2字节）

转移字符：\t(空格) \n(换行)

变量

变量作用域：类变量（static），实例变量，局部变量（方法）

局部变量：必须声明和初始化值

实例变量：从属于对象，如果不自行初始化，这个类型的默认(0,0.0,bolean默认值是False,除了基本类型，其他是null)

类变量:用static修饰

常量（Final）

命名规范

类成员变量和局部变量和方法名：首字母小写和驼峰原则，其他的单词首字母大写：lastName

常量：大写字母和下划线：MAX_VALUE

类名：首字母大写和驼峰原则，LastName

short+byte类型=int类型

运算

增增减减

位运算的左移：乘以2；位运算的右移除以2

int a=20
int b=10
System.out.println(a)
a+=b equals a=a+b
//字符串连接符
System.out.println(" "+a+b):1020
System.out.println(a+b+‘‘):30

三元运算符？ ：

x?y:z
如果x为true,则结果为y,否则为z
例子;
score<60?"不及格"："及格"

注意优先级

JavaDoc文档(可以注释在类或者方法上面)

/**
*@author
*@version
*@param
*@return
*@throws
**/

Scanner

Scanner scanner=new Scanner(System.in)
if(scanner.hasNextLine)//
    String s= scanner.nextLine

Scanner next()：空格为结束符

Scanner nextLine:以ENTER为结束符

java结构

顺序结构（基本结构）

选择结构（if单选择，if双选择，if多选择，）

switch:

byte\short\int\short\char

从java SE7开始,switch支持String类型

同时case标签必须为字符串常量或者字面量

For循环

注意点：最新执行初始化，检测布尔表达值，执行一次循环，在判断

增强型循环：适合于数组和集合循环调用

break:终止循环

continue:终止本次循环，开始新的循环

方法

类似于函数，用一段用来完成特定功能的代码片段

方法包含一个方法头和方法体，修饰符，返回值类型，方法名，参数类型，方法体

实参：实际调用传递给他的参数，调用方法时实际传给方法的数据

形参：用来定义作用的，在方法被调用时用于接收外界输入的数据

调用方法：对象名。方法名（实参列表）

注意：java是值传递

方法的重载

1. 方法名称必须相同

2. 参数列表必须不同，参数类型，顺序，个数

3. 方法的返回类型可以相同可以不相同

4. 可变参数：只能指定一个可变参数；必须放在方法中的最后一个参数的位置；任何一个普通的参数必须在它后面声明

public void test(int…… i){
System.out.println(i[0])
}
//调用
Demo04 demo04=new Demo04();
demo04.test(...i 1,2,3,4)

递归思想

递归结构包括两个部分（应用：计算阶乘）

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

• 递归体：什么时候需要调用自身方法

递归尽量少用，循环次数小可以用

数组

数组是相同类型数据的有序集合，下标从0开始

声明数组

int[ ] nums(推荐使用) int nums[ ]

创建数组,10个元素

int[ ]nums=new int[10]

给元素赋值，若不赋值为0

nums[0]=1;numbs[1]=9……

获取数组的长度 nums.length

初始化（一旦创建就有默认值）

1. 静态初始化 int[ ] a={1,2,3,4,5}

2. 动态初始化 int[ ] a=new int[ 2];a[0]=1,a[1]=2

数组的基本的特点：

长度确定，一旦被创建，大小不变；如果越界，则报下标错误

元素为相同类型

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

数组也是对象，数组元素相当于对象的成员变量，在栈中保存

二维数组（4行2列）

int array={{1,2},{2,3},{3,4},{4,5}}

array0=2

冒泡排序（八大排序）

1. 比较数组中，两个相邻的元素，如果第一个数比第二个数哒，，我们就交换他们的位置

2. 每一次比较，都会产生一个最大或者最小的数字

3. 下一轮则可以少一次排序

4. 依次循环，直到结束

面向对象编程（OOP：Object-Oriented Programming ）

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

三大特性：封装、继承、多态

回顾方法的调用

一个类写的静态static的方法，在其他类或者本类调用时候，直接用类名.方法名调用

若一个类写的非静态，不加static的方法，在其他类或者本类调用时候，要先类名实例化，Student student =new Student()

静态static和类一起加载，非静态方法和类实例化之后才存在

一个类里面只有一个public class，多个class

值传递：

引用传递：对象，本质还是值传递，可改变对象的属性

对象的引用：对象是通过引用来操作的，从栈到堆的索引

对象和类

类包括属性和方法

对象也是属性和方法

类实例化之后会返回一个自己的对象，对象就是类的实例

用new关键字创建的时候，进行初始化；初始化的默认值为基本类型的默认值（null或者0）以及对类中构造器的调用

数字：0,0,0；char:u0000;boolean:False;引用：null

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点:

构造器

构造器的特点

1.必须和类的名字相同

2.必须没有返回类型，也不能写void

构造器的作用（alter+insert）：

1.使用new关键字，本质是在调用构造器;一个类什么都不写，会存在一个无参构造器隐式

2.一旦定义了有参构造，无参必须显示定义

3.构造器的使用是初始化对象的值

public class Person{
String name;
//默认存在，实例化初始化new的时候调用
public Person(){}
}
public Person(String name){
    this.name=name
}
}

内存区

栈：main,引用变量名

堆 ：创建出来的对象

堆里面的： 方法区（静态方法区）

封装（属性私有：private）-alter+insert

程序设计追求：高内聚，低耦合

解释：高内聚是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是仅暴露少量的方法给外部使用

封装的是类的属性，用private,在调用时将无法通过类名+方法名直接调用，必须要给属性提供一些public的get和set方法

private String name;//public String name
public String getName(){
return this.name;
}
public void setName(String name){
     this.name=name;
}

封装的意义

1. 提高程序的安全性，保护数据

2. 隐藏代码的实现细节

3. 统一接口

4. 系统可维护性增加

继承(类里面ctrl+H)

继承是对某一批类的抽象，extends ,子类（派生类）是对父类（基类)的扩展

JAVA类只有单继承，没有多继承！一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子

继承是类和类之间的关系

子类继承了父类，那么可以继承父类的所有方法，前提修饰符是public

在Java中，所有类默认直接后者间接继承Object类

私有的东西无法被继承

注意：

super

1. super调用父类的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法中

3. super和this不能同时调用构造方法

this

1. 代表对象不同

• this:本身调用者这个对象

• super：代表父类对象的应用

2. 前提：this没继承也能使用；super只能在继承条件下才可以使用

3. 构造方法

this（）:本类的构造

super(): 父类的构造

方法重写（前提继承，和属性无关，非静态方法，@override）

父类的引用指向了子类

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

A extends B
B b=new A()

总结：

1. 前提继承关系，子类重写父类的方法

2. 方法名必须相同

3. 参数列表必须相同

4. 修饰符：范围可以扩大，不可以缩小，poublic>protected>Default>private

5. 抛出的异常，范围，可以被缩小，但不能扩大：ClassNot

6. 子类和父类必须一致，方法体不同

重写的作用：

1. 父类的功能，子类不一定需要，或者不一定满足

2. alter+insert快捷键

多态（前提是继承关系）

父类的引用指向子类

一个对象的实际类型是确定，引用类型不确定

对象能执行哪些方法，主要看左边的数据类型，与右边关系不大

注意事项

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

2. 父类和子类有联系，类型转换异常，ClassCastException

3. 存在条件:有继承关系，子类重写父类方法，父类引用指向子类对象 Father f1=new Son()

   • static 方法，属于类，他不属于实例

   • final常量

   • private方法

instanceof (Object instanceof Student,结果为true)

强制转换

子类转换为父类，向上转型，不用强制转换，可能丢失自己本来的方法

父类转换成子类，向下转型，需要强制转换

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

Static关键字

静态属性

一个类写的静态static的方法，在其他类或者本类调用时候，直接用类名.方法名调用

若一个类写的非静态，不加static的方法，在其他类或者本类调用时候，要先类名实例化，Student student =new Student()

静态方法

非静态方法可以直接调用静态方法，静态方法里面可以调用静态方法，不能调用非静态方法

静态代码块：只执行一次

赋初值：匿名代码块

final不能被继承

抽象类（abstract，继承）

abstract可以修饰类或者方法

抽象方法，只有方法的名字，没有具体实现

抽象类的所有方法必须由继承他的子类来实现方法

1. 不能new抽象类，只能靠子类去实现它

2. 抽象类里面的方法可以有抽象方法或者普通方法，但是一旦某类中有抽象方法，该类必须定义为抽象类

接口可以多继承

接口（interface定义）

自己无法写方法，专业的约束，面向接口编程，约束和是实现分离

接口就是规范，接口的本质是契约

接口中的所有定义方法其实都是抽象的，public abstract；public static final 属性都是常量

接口都需要实现类implementes；实现了接口的类，就需要重写接口中的方法

利用接口实现多继承

接口不能被实例化，接口中没有构造方法

内部类

内部类就是在一个类的内部定义了一个类

1. 成员内部类

2. 匿名内部类

……

异常（异常处理框架）

异常类分为两大类，错误Error和异常Exception

假设捕获多个异常，从小到大

快捷键，选中Ctrl+Alt+T

try{ //监控区域}
catch(Exception e){ //捕获异常，Error,Exception最高为Throwable
e.printStackTrace
}
finally{//永远执行}

主动抛出异常 throw，throws

自定义异常步骤：

1. 创建自定义异常类

2. 在方法中通过throw关键字抛出异常对象

3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续下一步操作

4. 在出现异常方法的调用者中捕获并处理异常

throw和throws区别

throw是语句抛出一个异常。

语法：throw (异常对象); throw e;

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)

语法：(修饰符)(方法名)([参数列表])[throws(异常类)]{......}

public void doA(int a) throws Exception1,Exception3{......}

自定义异常

JAVA基础-狂神说

原文：https://www.cnblogs.com/womenyouni/p/14744636.html