java返回值 文字_java基础总结（文字）

01标识符/关键字/基本类型(四类八种)

注释：

代码的解释，不会变jvm执行的。

//单行

/*

多行

*/

/**

文档

*/

关键字

java中含有特殊含义的英文单词。public void，关键字不用单独用作取名字。

标识符

java取名字。(相同项目不能有相同包名，相同包不能有相同类名，相同作用域不能有相同变量名)

包名：com.test.helloworld

类名：HelloWorld

方法名：main

参数名/变量名：args

规则：不能以数字开头  _$ HelloWorld 。 不要用汉字

约定：

驼峰命名法：

类名：HelloWorld   每个英文单词首字母大写

方法名/变量名：main getAge getStudentAge除了第一个单词外其余首字母大写。

===============================================================

逻辑类型

boolean(布尔类型)，取值范围为true/false

整型(整数)

byte(字节型)，取值范围：-128~127   1字节

short(短整型)，取值范围：-32768~32767     2字节

int ( 整型)，取值范围：-2147483648~2147483647 4字节

long (长整型)取值范围：-9223372036854775808~9223372036854775807  8字节

浮点型(小数)

float(单精度的浮点型)1.4E-45~3.4028235E38 4字节

double (双精度的浮点型)4.9E-324~1.7976931348623157E308 8字节

字符型

char(字符型)：char类型的变量，赋值的时候数据长度只能是一位，并且用’’包起来。2字节

拥有后缀(大小写都行)：

long l = 10000L;

float f = 3.14F;

double d = 3.33D;

===============================================================

目前变量的定义必须写在main方法里面。

public class VarDemo {

public static void main(String[] args) {

//main + alt + /

//变量定义的格式：

//数据类型 变量名=变量的值;

boolean b1 = true;

boolean b2 = false;

//整数类型 默认类型是int

byte byte1 = 127;

short s = 130;

int x = 4;

x=5;

int y = 10;

x = y;

long l = 2147483648L; //l L表示是一个long，推荐使用大写

//浮点,浮点类型默认类型是double

float f = 3.14F; //f F表示是一个float，推荐使用大写

double d = 3.14D; //D d表示是一个double，推荐使用大写

//字符类型

char c =  ' '; //单引号之间只能有一个值

//java 大的数据类型不能直接赋值给小的数据类。

}

}

02变量/一维数组、二维数组/运算符

变量：

相同的作用域下不能有同名的变量。

基本数据类型：

存的就是具体的值。

int x = 3;

引用数据类型：

存的是一个地址值。(简单理解通过门牌号能找到楼盘)

字符串：

String s = "ABC";

数组：

数组就是一个容器(存储多个东西的器皿，抽屉)。

容器的特点：

定长、固定数据类型。

索引：

下标，从0开始

初始化就是赋值，赋值就是初始化。

一维数组的格式1：

数据类型[] 数组名= new数据类型[数组的长度];

int[] arr = new int[3];

一维数组的格式2：

数据类型[] 数组名= {值1,值2,值3,值4};

int[] arr3 = {1,2,3,4,3,4,5,6,8,9,2,3};

获取长度

数组名.length;

arr.length;

取值/赋值******：

arr[0] = 10;

System.out.println(arr[0]);

二位数组的初始化格式1：

数据类型[][] 数组名= new数据类型[二位数组的长度][];

int[][] arr = new int[3][3];

二位数组的初始化格式2(优先掌握这一种，这种会更容易理解)********：

数据类型[][] 数组名= {{值1，值2，}，{值1，值2}，{值1，值2}};

int[][] arr2 = {{1,2},{3,4},{5,6},{1}};

取值/赋值：

arr[0][0] = 20;

System.out.println(arr[0][0]);

异常：运行出现了错误

NullPointerException

null 值调用属性或者方法

ArrayIndexOutOfBoundsException

访问了不存在的索引

运算符

算数运算符

% 取余 取模

++ -- 自增1自减1

单独使用时，++ 放前和放后没有区别，都是+1；

参与运算,++在后面先把变量x的值取出来赋值(运算)，再自增1

参与运算,++在前面先把变量x自增1，再把值取出来赋值(运算)

关系运算符，结果boolean

== 比较相等

!= 比较不相等

逻辑运算符，结果也是boolean

& | ! && ||

& 遇false则false

| 遇true则true

&& 短路：如果左边已经决定了整个表达式的结果，那么右边不会执行

赋值运算符

int a = 10;  //把10赋值给a变量；

扩展赋值运算符 += *= /= %=; 底层包含强制类型转换

//把左边和右边的值进行运算后赋值给左边。

a +=10; //a = (int)(a+10);

三元运算符

boolean结果的表达式?结果1 :结果2;

true 返回 结果1，false返回结果2;

03循环for、while、dowhile/流程控制语句if、switch

循环

1、格式

for(初始化语句1 ;条件判断语句2 ;循环体执行之后的语句4) {

循环体 3 ;

}

2、执行流程

1 --> 2 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2 false 结束

true true

最少

1 --> 2 false 结束 循环的右大括号

增强for循环:

for(数据类型 变量名:数组或者集合名) {

}

增强for和普通for的区别是：增强for不能直接拿到索引。

求和思想：

int sum = 0;

for (int i = 1; i <= 10; i++) {

sum += i;

}

System.out.println(sum);

while格式：

初始化语句 1

while(条件判断语句2) {

循环体3;

循环体执行之后的语句4;

}

执行流程 : 和for是一样

1 --> 2 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2 false 结束

true true

最少

1 --> 2 false 结束 循环的右大括号

do while 格式(了解)

初始化语句 1

do {

循环体3;

循环体执行之后的语句4;

}while(条件判断语句2);

特点：do while 至少会执行一次循环体。

循环控制语句

continue; //跳出本次循环，继续下次循环

break; //跳出全部循环

嵌套循环

for (int i = 1; i <= 4; i++) { //控制行

for (int j = 1; j <= 5; j++) { //控制列

System.out.print("*");

}

System.out.println();

}

条件控制语句

1、格式

2、执行流程

格式1：

if() {

true进入if语句体

}

格式2：

if() {

true进入if语句体

}else {

false进入else语句体

}

格式3：

if() {

当前true进入if语句体

}else if () {

当前true进入if语句体

}else if () {

当前true进入if语句体

}...

else {

所有的if或者else if都不满足则进入else

}

格式3和多个if的区别

格式3是分支流程，最终只会进入一个if。

多个if是只要满足条件就能进入if，不存在互斥。

switch(了解)

switch(值) {

case 值1:

语句；

break;

case 值2:

语句；

break;

case 值3:

语句；

break;

default:

语句；

break;

}

switch(值)值的类型：byte、short、int、char、String、枚举

switch什么时候结束，遇到break和}。

break穿透：没有遇到break，不会再次进行case匹配。

if和switch的区别：

if的第三种格式

if else if .... else

和switch执行流程是非常相似的。

switch需要匹配的值是一个范围的时候，那么很难用。

if的条件更加丰富，只要表达式结果是boolean类型就ok。

switch只是一个值的比较。

什么时候用switch:只比较值是否相等，且数量较少的时候。性能高过if。

95%都使用if。

04面向对象概念/方法、构造方法/成员变量和局部变量的区别

函数/方法：

函数就是功能实现，它是遵循了特定语法，一段具有特定功能代码。(类通过定义函数来描述类的功能)

位置：类中方法外，与main方法平级*******

***********方法不调用，不执行***********

分类：

非构造函数(普通函数)

格式：

按照main方法修改。

修饰符 函数返回值类型 函数名(参数类型 参数名...){函数体}

public int add(int a,int b){

return a+b;

}

修饰符：

public

protected

默认修饰符

private

权限逐步降低。

public的访问权限最大。private类型的访问权限最小

函数返回值类型：

八大基本类型 / 引用类型/空类型(void)

函数名：

随便定义，语法要求第一个字母小写，函数名要见名知意。

参数类型：

就是一个变量的类型(八大基本类型 / 引用类型)

形参实参：(不要纠结)

形参：方法参数列表

实参：真实参数入的值，实际参与运算的值。

面向对象概念

面向对象：把事情交给对象完成(厨师、快递员)，对象具备完成某件事情的人或物。

面向过程：自己一条龙完成所有事情

类于对象

模板，描述的是具有共性的一类事物，所以我们又可以把类称作模板技术，

静止的(属性用`变量`来描述)和(动态的行为用`函数`来描述)。

例子：

手机、汽车，鱼、狗

对象：类的具体化

构造函数

创建对象，兼职成员对属性就行赋值。

分类:

无参构造函数(默认构造函数)

public 类名() {

}

带参数构造函数

public 类名(参数类型 参数名) {

}

注意细节:

函数名必须跟类名保持一致

不需要声明函数返回值

如果在类中定义了任意构造方法，那么java不再提供默认空参构造方法

成员变量和局部变量的区别：

局部变量特点：

定义在函数体内

定义在函数参数列表里

代码块中{}

成员变量特点

定义在类体内

在函数外

在代码块外

生命周期：

局部变量出了包含他的{}就死亡

成员变量对象不消亡就一起存在

如何调用函数

05方法重载/继承/方法重写/super关键字和this关键字

1、方法\函数重载

规则：方法名一样，参数不一样，与返回值无关

参数的个数不一样

参数的类型不一样

如果参数个数一样,类型也一样，但是顺序不一样

普通方法和构造方法都能重载

2、java内存(了解)

java的内存包含了栈、堆、方法区、寄存器

栈：

先进后出

局部变量、方法都在栈中

堆：

new出来的对象就在堆

两个引用(变量)指向同一个对象(理解+掌握)。

Student s = new Student();

Student s2 = s;

3、封装(把代码放入方法)    三大特征都是为了少些代码少修改代码。

Encapsulation。意思是将代码通过函数的形式将一些代码细节包装起来，防止外部代码的随机访问，

要访问这些数据就必须通过调用函数来完成。

好处：

提高了代码的阅读性

提高了代码的可维护性

体现：方法、对象、private get/set

get/set和构造方法都可以对成员变量进行赋值。

4继承inherit

生活中的继承：子承父业。

java中的继承：两个类之间通过extends关键字来描述父子关系，子类便可拥有父类的非私有成员。

解决问题

提高了代码复用性

代码的维护性更高

语法：

public class 父类{

}

public class 子类extends父类{

}

注意事项：

如果一个类不继承任何类，默认继承Object,Object是java中的祖宗类。

Java是单继承(一个类只能继承于一个类)，多层继承，一个父类可以有多个子类。

创建本类对象之前会先初始化父类对象

子类不能继承父类的private成员(属性，方法)

5、方法重写/覆盖

前提条件：继承或者实现

子父类中出现了一模一样的方法。修饰符、返回值、方法名、参数都必须一模一样。

作用：方法升级。

6、super关键字与this关键字

super指向父类(调用父类方法或属性时候用到)

this指向当前类(区分局部变量和成员变量同名)

super() 调用父类构造方法

this() 调用本类其他构造

7、修饰符

访问修饰符

public protected 默认修饰符private

权限逐步降低。

public的访问权限最大。private类型的访问权限最小

非访问修饰符

static 静态(共享) 后面会通过实际例子讲解

final 常量、最终类(不能被继承，被绝育了)方法(不能被重写)

abstract 抽象

06多态/api使用/字符串方法学习

1、多态Polymorphism少写代码

概念：用父类的类型来接收子类的对象

先决条件：

继承/接口实现

父类类型接收子类对象

优点：

扩展性强，解决了代码复用，降低类型耦合度

可以少定义变量，少些重复代码。

案例：一个方法接受不同的子类类型。

缺点：

不能使用子类特有方法

可以使用强转，转成对应子类类型，解决这个问题。

使用方法:

父类 变量名1 = 子类对象;

子类 变量名2 = (子类)变量名1;

多态一般伴随重写使用。

场景：

public void driverCar(Car car) {

car.run();

}

2、api使用

打开->显示->索引->输入java提供的类

3、字符串

原理:

char[] ch = {'a','b','c'};

特点：

方法不能改变String本身

方法

equals：判断字符串是是否一样，大小写敏感

split：切割

replace：替换

substring：字符串截取

trim：删除字符串两端的空格

length：获取字符串长度

equalsIgnoreCase：判断是否一样，忽略大小写

indexOf：获取指定内容在字符串中出现的位置

isEmpty：判断字符串是否为空

lastIndexOf：获取要匹配内容在字符串中最后出现的位置

构造方法：

基本不用。

4、==和equals区别

== 比较基本数据类型比较的是值，比较引用数据类型比较的是地址值。

equals 是Object类中的方法，基本数据类型无法调用。

equals默认使用==号，重写之后一般比较的是内容。