JAVA基础

java 特性

封装：

  • 封装指的是属性私有化，根据需要提供setter和getter方法来访问属性。即隐藏具体属性和实现细节，仅对外开放接口，控制程序中属性的访问级别。
  • 目的：增强安全性和简化编程，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员。

继承：

  • 继承是指将多个相同的属性和方法提取出来，新建一个父类。
  • Java中一个类只能继承一个父类，且只能继承访问权限非private的属性和方法。 子类可以重写父类中的方法，命名与父类中同名的属性。
  • 目的：代码复用。

多态：

  • 多态可以分为两种：设计时多态和运行时多态。
  • 设计时多态：即重载，是指Java允许方法名相同而参数不同（返回值可以相同也可以不相同）。
  • 运行时多态：即重写，是指Java运行根据调用该方法的类型决定调用哪个方法。
  • 多态目的：增加代码的灵活度。

抽象：只公开与数据类型交互有意义的操作，对外界隐藏了所有实现细节

Java 三大版本

一次编写 到处运行 （jvm）跨平台

  • javaSE：标准版（桌面程序）
  • javaME：嵌入式开发（手机，家电）
  • javaEE：企业级开发（web端，服务器开发）

JDK JRE JVM

JDK：Java Development Kit java开发工具包，用来开发Java程序的，针对java开发者

JRE：Java Runtime Environment java运行时环境，针对java用户

JVM：Java Virtual Machine java虚拟机 用来解释执行字节码文件(class文件)的

JDK包涵了JRE
JRE包涵了JVM

数据类型

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

基本数据类型

基本数据类型只有四类八种

  • 整数类型

  •   byte    占用1个字节     1byte = 8bits  默认值为0

  •   short   占用2个字节     1byte = 16bits     默认值为0

  •   int     占用4个字节     1byte = 32bits     默认值为0

  •   long    占用8个字节     1byte = 64bits     默认值为0L

  • boolean类型

  •   占1位     true/false     默认值false

  • 浮点型

  •   float     单精度浮点型 占用4位    1float = 32 bits   默认值0.0f

  •   double     单精度浮点型  占用8位    1float = 64 bits   默认值0.0d

  • 字符类型

  •   char    可以存储任何字符 例如 char a = 'A'

对应包装类：Byte Short Character Integer Long Boolean Double Float

数值类型 字节范围
byte 占1个字节 -128 —127
short 占2个字节 -32768—32767
int 占4个字节 -2147483648—2147483647 ±21亿
long 占8个字节 -9223372036854775808—9223372036854775807
float 占4个字节
double 占8个字节
char 占2个字节
boolean 占1个字节 true/false

进制问题：

public class demo {public static void main(String[] args) {//整数类型 二进制0b开头  十进制  八进制0开头  十六进制0x开头int i = 10;int i2 = 010; //8进制int i3 = 0x10; //16进制 0-9 A-FSystem.out.println(i);System.out.println(i2);System.out.println(i3);//浮点数//float  比较离散 有舍入误差  算出的值都是约等于  接近但不等于//doublefloat f = 1.1111f;double d = 1.1111;System.out.println(f);System.out.println(d);System.out.println(f==d);//falsefloat fl = 1234567821341423412f;float fl2 = fl+1;System.out.println(fl==fl2);//true//字符型char c = 'A';char c1 = '我';System.out.println((int)c);//65System.out.println((int)c1);//25105//布尔类型boolean flag = true;if (flag == true){}if (flag){}}
}
10
8
16
false
true

引用数据类型

类
接口
数组

字节

  • 位（bit）：计算机内部存储数据的最小单位

  • 字节（byte）：是计算机中数据处理的基本单位，一般使用B表示

  • 1B（byte，字节）= 8bit

  • 字符：指计算机中使用的字母，数字，字和字符。

  • 1bit表示1位

  • 1Byte表示一个字节 1B = 8b

  • 1024B = 1kb

  • 1024kb = 1M

  • 1024M = 1G

注：电脑中32位系统和64位系统

32位系统最大内存只能扩容到32gb 64位系统可支持128g

类型转换

强制转换：变量名 高->低

自动转换：低->高

  • 不能对布尔值类型转换
  • 不能吧对象类型转换为不相干类型
  • 在把高容量转换低容量时候强制转换
  • 强制转换可能存在内存溢出，或者精度丢失

变量

  • 每一个变量必须声明其类型
  • 类型可以是基本类型，也可以是引用类型
  • 变量名必须是合法的标识符
  • 变量名是一条完整语句，分号结尾
int i = 10；
//数据类型  变量名 = 值

变量的作用域

  • 类变量 （加static关键字，类加载的时候就创建）
  • 实例变量 （在对象中，可以不对其初始化值，有默认值）
  • 局部变量 （在方法中，必须声明和初始化）

变量命名规范

  • 所有变量，方法名，类名，见名知意
  • 类成员变量：首字母小写和驼峰原则
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线
  • 类名：首字母大写和驼峰原则
  • 方法名：首字母小写和驼峰原则

常量

  • 初始化后不能改变再改变值
  • 一般用大写
final  常量名 = 值
final String name = "w";

运算符

  • 算数运算符：+，-，*，/，%，++，–
  • 赋值运算符：=
  • 关系运算符：>，<，>=，<=，==，!= instance of
  • 逻辑运算符：&&，||，！
  • 位运算符：&，｜，^，～，>>，<<，>>>
  • 条件运算符：？，：
  • 扩展赋值运算符：+=，-=，*=，/=
public class Demo04 {public static void main(String[] args) {int a = 1;int b = 1;System.out.println(a++);//1  先赋值，后自增System.out.println(--b);//0  先自增，后赋值int c = 10;int d = 3;System.out.println(c%d);//取模 求余数  }
}
public class Demo05 {public static void main(String[] args) {//与 或 非boolean a = true;boolean b = false;System.out.println(a&&b);//逻辑与运算：两个变量都为true，结果才为trueSystem.out.println(a||b);//逻辑或运算：两个变量有一个为true，结果就为trueSystem.out.println(!(a&&b));//取反：如果为真，则变为假  如果为假，则变为真//短路与：如果左边为false，结果为false，不会运算后面等式//短路或：如果左边为true，结果为true，不运算后边等式}
}

public class Demo06 {public static void main(String[] args) {int a = 10;int b = 20;a+=b;//a=a+ba-=b;//a=a-b;System.out.println(a);int c =10;String aq = String.valueOf(c);//字符串连接符System.out.println(""+a+b);//1020  字符串在前转成string 会进行拼接System.out.println(a+b+"");//30  字符串在后先相加 再转换成字符串}
}

关键字

关键字 含义
abstract 表明类或者成员方法具有抽象属性
assert 断言，用来进行程序调试
boolean 基本数据类型之一，声明布尔类型的关键字
break 提前跳出一个块
byte 基本数据类型之一，字节类型
case 用在switch语句之中，表示其中的一个分支
catch 用在异常处理中，用来捕捉异常
char 基本数据类型之一，字符类型
class 声明一个类
const 保留关键字，没有具体含义
continue 回到一个块的开始处 跳过
default 默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
do 用在do-while循环结构中
double 基本数据类型之一，双精度浮点数类型
else 用在条件语句中，表明当条件不成立时的分支
enum 枚举
extends 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float 基本数据类型之一，单精度浮点数类型
for 一种循环结构的引导词
goto 保留关键字，没有具体含义
if 条件语句的引导词
implements 表明一个类实现了给定的接口
import 表明要访问指定的类或包
instanceof 用来测试一个对象是否是指定类型的实例对象
int 基本数据类型之一，整数类型
interface 接口
long 基本数据类型之一，长整数类型
native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new 用来创建新实例对象
package 包
private 一种访问控制方式：私用模式
protected 一种访问控制方式：保护模式
public 一种访问控制方式：共用模式
return 从成员方法中返回数据
short 基本数据类型之一,短整数类型
static 表明具有静态属性
strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super 表明当前对象的父类型的引用或者父类型的构造方法
switch 分支语句结构的引导词
synchronized 表明一段代码需要同步执行
this 指向当前实例对象的引用
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
transient 声明不用序列化的成员域
try 尝试一个可能抛出异常的程序块
void 声明当前成员方法没有返回值
volatile 表明两个或者多个变量必须同步地发生变化
while 用在循环结构中

关键字一律用小写字母标识，按其用途划分为如下几组。

  • 用于数据类型。 用于数据类型的关键字有 boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof。
  • 用于语句。 用于语句的关键字有break、case、 catch、 continue、 default 、do、 else、 for、 if、return、switch、try、 while、 finally、 throw、this、 super。
  • 用于修饰 用于修饰的关键字有 abstract、final、native、private、 protected、public、static、synchronized、transient、 volatile。
  • 用于方法、类、接口、包和异常。 用于方法、类、接口、包和异常的关键字有 class、 extends、 implements、interface、 package、import、throws。
  • 还有些关键字如cat、 future、 generic、innerr、 operator、 outer、rest、var等都是Java保留的没有意义的关键字。
  • Java还有3个保留字:true、false、null。它们不是关键字，而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。

流程控制

1. Scanner

  • java.util.Scanner 类可以获取用户的输入

  • Scanner scanner = new Scanner(System.in);

  • 通过Scanner类的next()与nextLine()方法获取输入的字符串，读取前使用hasNext和hasNextLine()判断是否还有输入的数据

Next

  • 一定要读取到有效字符后才可以结束输入
  • 对输入有效字符之前遇到的空格，next()方法会自动将其去掉
  • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  • next()不能得到带有空格的字符串

nextLine()

  • 以Enter为结束符，也就是说返回的是输入回车之前的所有字符
  • 可以获得空格
public class Demo01 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);if (scanner.hasNext()){String s = scanner.next();//空格后面读取不到 以空格结束System.out.println(s);}if (scanner.hasNextLine()){String s1 = scanner.nextLine();//可以读取空格后面字符 以Enter结束System.out.println(s1);}scanner.close();}
}

public class Demo02 {public static void main(String[] args) {double sum = 0;//和int num = 0;//个数Scanner scanner = new Scanner(System.in);while(scanner.hasNextDouble){doouble d = scanner.nextDouble();num++;sum = sum + d;}System.out.println(sum);System.out.println(num);System.out.println(sum/num);//平均值scanner.close();}
}

2. if语句

//if单选择结构
if(){}
//if双选择结构
if(){}else{}
//多选择结构
if(){}else if(){}else if(){}else{}
//if嵌套结构
if(){if(){}
}

3. Switch语句

  • switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
  • switch语句中变量的类型可以是byte，short，int，char
  • jdk 7 开始支持string类型
  • 同时case标签必须为字符串常量或字面量
  • 每个case后带上break，防止case穿透
public class Demo03 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入");String s = scanner.nextLine();switch(s){case "A":System.out.println("a");break;//加上break防止case穿透case "B":System.out.println("b");break;case "C":System.out.println("c");break;default:System.out.println("...");}scanner.close();}
}

4. while 循环

while(布尔表达式){//循环内容
}
  • 只要布尔表达式为true，循环就会一直执行下去
  • 大多数情况下会让循环停止下来，需要一个让表达式失效的方式结束循环
  • 少部分情况需要循环一直执行，比如服务器的请求相应监听
  • 循环条件为true就会造成无限循环，死循环，正常业务中需要避免，回影响程序性能
public class Demo04 {public static void main(String[] args) {//计算1+2+...+100int i = 0;int sum = 0;while (i<100){i++;System.out.println(i);sum = sum + i;}System.out.println(sum);}
}

5. do while 循环

do{//代码块
}while(布尔表达式);
  • 对于do while而言，如果不满足条件，则不能进入循环
  • do while 和while区别
    • while先判断后执行，do…while先执行后判断
    • do…while总是保证循环体至少执行一次
public class Demo05 {public static void main(String[] args) {int i = 0;int sum = 0;do {i++;sum = sum + i;}while (i<100);System.out.println(sum);}
}

6. for循环

  • for循环是支持迭代的一种通用结构
  • for循环执行的次数是在执行前就确定的
for(初始化,布尔表达式,更新){//代码块
}
for(int i = 0;i < 10;i++){//代码块
}

计算0-100之间奇数和偶数的和

public class Demo06 {public static void main(String[] args) {//计算0-100之间奇数和偶数的和int i = 0;int jiSum = 0;int ouSum = 0;while (i<=100){if (i%2==0){ouSum = ouSum + i;}else {jiSum = jiSum + i;}i++;}System.out.println(jiSum);System.out.println(ouSum);}
}
public class Demo07 {public static void main(String[] args) {//计算0-100之间奇数和偶数的和int jiSum = 0;int oiSum = 0;for (int i = 0; i <= 100; i++) {if (i%2==0){jiSum+=i;}else {oiSum+=i;}}System.out.println(jiSum);System.out.println(oiSum);}
}

用while或for循环输出1-1000之间能被5整除的数，并且每行输出三个

public class Demo08 {public static void main(String[] args) {//用while或for循环输出1-1000之间能被5整除的数，并且每行输出三个for (int i = 1; i <= 1000; i++) {if (i%5==0){System.out.print(i+"\t");}if (i%15==0){System.out.println();}}}
}

打印九九乘法表

public class Demo09 {public static void main(String[] args) {//打印九九乘法表for (int j = 1; j <= 9; j++) {for (int i = 1; i <= j; i++) {System.out.print(j+"*"+i+"="+j*i+"\t");}System.out.println();}}
}

7. 增强for循环

for(声明语句:表达式){//代码块
}
  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
  • 表达式：就是要访问的数组名，或者返回值为数组的方法

8. break continue

  • break在任何循环体语句的主题部分，均可用break控制循环的流程。==break用于强行退出循环，==不执行循环体中剩余的语句。break语句也可以在switch语句中使用
public class breakDemo {public static void main(String[] args) {int i = 0;while (i<10){i++;if (i==5){break;}System.out.println(i);}}
}
  • continue语句用在循环语句体中，用于跳过本次循环，继续进行下一次循环判断
public class continueDemo {public static void main(String[] args) {int i = 0;while (i<100){i++;if (i%10==0){continue;//跳过10，继续循环}System.out.print(i+" ");}}
}

9. 三种循环区别