JAVA基础复习笔记

最新推荐文章于 2024-08-10 16:13:20 发布

eight-sasagawa

最新推荐文章于 2024-08-10 16:13:20 发布

阅读量80

点赞数

文章标签： java

本文链接：https://blog.csdn.net/eight_sasagawa/article/details/120477714

版权

JAVA基础

1. 注释

1.单行注释：
//
2.多行注释：
/* /
3.文档注释
/*
*
*/

2. 数据类型

long  num1=10L;//用大写L，防止l看成1
float num2=20.1f;
char name ='国';
boolean flag=true; 
//boolean flag=false;

1. 整数拓展

二进制0b
八进制0
十六进制0x

2. 浮点数拓展

//float 有限 离散 舍入误差  接近但不等于
//最好完全避免使用浮点数进行比较
//BigDecimal 数学工具类（银行计算用）

float f=0.1f;
double d=1.0/10;
System.out.println(f==d);//false

float d1=2324343253423f;
float d2=d1+1;
System .out.println(d1==d2);//true

3. 字符拓展

String sa=new String("Hello world");
String sb=new String("Hello world");
String sc="Hello world";
String sd="Hello world";
System.out.println(sa=sb);//false
System.out.println(sc=sd);//true
//new开辟了新地址，比较的是地址所以不相等

3. 类型转换

//所有数据计算前先转换为同一类型数据
int i=128;
byte b=(byte)i;//内存溢出
//强制转换  （类型）变量名 高--低
//自动转换   低--高

1.注意点

不能对布尔值进行转换
不能把对象类型转换为不相干类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能存在内存溢出，或者精度问题

JDK7往上新特性：数字之间可以用下划线分割

//操作比较大的数时，注意溢出问题
int money=10_000_000;
int years=20;
int total=money*years;//-1474836480 计算溢出
long total2=money*years;//默认是int，转换之前已经存在问题了
long total3=money*((long)years);//先把一个整数转换为long

4. 变量

public class Variable{
  static int allClicks=0; //类变量  static关键字 从属类
  String str="Hello wrold";
  //实例变量：必须声明和初始化值，如果不初始化则为默认值0 0.0 
  //布尔值：默认为false;
  //除了基本类型，其余默认值都为null；
  
  public void method(){
  int i=0;//局部变量
  }
}

1. 变量命名规范

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

5. 常量

//初始化后不能再改变的值
final double PI=3.14;
//常量名一般使用大写字符

6. 运算符

int a=3;
int b=a++;//b的值为4
//a先自增再赋值给b   
int c=++a;//c的值为4
//a先赋值给c再自增
int d=a;//d的值为5

//and（&&） or（||） 取反（！）
/*
A=0011 1100
B=0000 1101
A&B=0000 1100 同为真则为真
A|B=0011 1101 有一真则为真
A^B=0011 0001 仅一真则为真
~B=1111 0010  取反

<<  左移 *2
>>  右移 /2
0000 0000  0
0000 0010  2
0000 0100  4
0000 1000  8
0001 0000  16
(2<<3)=2*2*2*2=16
*/

a+=b; //a=a+b
//字符串连接符 +
int a=10;
int b=20;
System.out.println(""+a+b);//输出： 1020
System.out.println(a+b+"");//输出：30

//x ? y: z
//如果x==true，则结果为y，否则为z

7. 包机制

类比文件里包含文件
一般采用公司倒置域名做包名：com.wang.xxx
包成员使用"import"语句导入

8. Scanner对象

Scanner scanner=new Scanner(System.in);
//Scanner类的next(),nextLine()获取输入的字符串
/*
next():
1. 读取有效字符后结束输入
2. 自动去掉输入有效字符之前的空格
3. 只有输入有效字符后的空白作为分隔符或结束符
4. 不能得到带有空格的字符串
nextLine():
1. 以Enter为结束符
2. 可以获取空白
3. */
//hasNext(),hasNextLine()判断是否还有输入的数据
/*
例：
while(scanner.hasDouble()){
System.out.println("scanner.nextDouble()");
} 
//此循环直到输入的不为double类型的数据结束循环
*/
//用完关闭 
scanner.close();

9. 选择结构

/*if(布尔表达式){

}else if(){

}...
...
else(){

}
*/

/*
switch(expression){ //expression类型：byte,short,int,char,String
case value:         //value必须为字符串常量或字面量
//语句
break：
case value:
//语句
break：
...
default:
//语句
}
*/

10. 循环结构

/*
while(布尔表达式){
//循环内容
}
//大多数情况会使用一个让表达式失效的方式结束循环
//少部分情况如服务器请求的响应，监听等需要循环一直执行

for(初始化;布尔表达式;更新){
//代码语句
}

//九九乘法表
for(int i=1;i<10;i++){
         for(int j=1;j<i+1;j++){
             System.out.print(i+"*"+j+"="+i*j+" ");
     }
         System.out.println();
     }
     
for(声明语句 ：表达式){
//代码语句
}
//例：遍历数组元素
int[] numbers={10,20,30,40,50};
for(int x:numbers){  
System.out.println(x);
}

break:强行退出循环
continue：跳过本次循环

//例：三角形
for(int i=1;i<=5;i++){
         for(int j=5;j>=i;j--){
             System.out.print(" ");
     }
         for(int j=1;j<=i;j++){
             System.out.print("*");
         }
         for(int j=1;j<i;j++){
             System.out.print("*");
         }
         System.out.println();
     }
*/

11. 方法

一个方法只实现一个功能，利于后期的扩展

1. 方法体

/*
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
*/
//JAVA中只有值传递，没有引用传递

2. 重载

相同的方法名，不同的参数类型或数量：
调用方法时自动根据相应参数类型和数量调用对应的方法

3. 可变参数

public void test(double j, int... i){}
//可以有不定个int类型的参数
//可变参数须在所有参数最后

4. 递归

能不用递归就不用，占用空间大
递归结构=递归头+递归体

//n的阶乘
public static int f(int n){
if(n==1){
return 1;
}else{
return n*f(n-1);
}
}

12. 数组

声明：dataType[ ] arrayRefVar;//首选方法
dataType arrayRefVar[ ] //效果相同但不是首选方法

new创建：dataType[ ] arrayRefVar= new dataTyper[arraySize];

特点：

长度确定，一旦创建大小不可变
元素类型必须相同
数值变量属引用类型，数组也可看成对象，数组中的每个元素相当于该对象的成员变量
数组对象本身是在堆中的

二维数组

int a[][]=new int[2][5];
int[][] array={{1,2},{3,4},{4,5}};

1. Arrays类

Arrays类中的方法都是statics修饰的静态方法，可以直接用类名调用

//打印数组元素 Arrays.toString（）
System.out.println(Arrays.toString(array));

//数组进行排序：升序
Arrays.sort(array);
//......

13. 类与对象

非静态方法需要new进行实例化才能调用（不存在），静态方法直接调用（已经存在）

类是一种抽象的数据类型，对象是抽象概念的具体实例

1. 创建与初始化对象

使用new关键字创建对象：分配内存空间并进行默认初始化以及对类中构造器的调用
类中的构造器即构造方法，在创建对象时必须调用的并且必须和类名相同而且没有返回类型

例：

 //学生类
 public class Student{
 //属性字段
 String name;
 int age;
 //构造方法(new的本质就是调用构造方法)
 public Student(String name,int age){
 this.name=name;
 this.age=age;
 }
 //方法
 public void study(){
 System.out.println("学习");
 }
 }
 
 //实例化
 Student xiaoming=new Student("小明",3);

2. 封装

私有成员变量需调用类中的get和set方法才能使用

14. 继承

extends意为扩展，子类扩展了父类且JAVA中只有单继承

子类继承父类的public方法

//当有相同属性时
public void test(String name){
System.out.println(name);//输出参数的name
System.out.println(this.name);//输出类中name默认值
System.out.println(super.name);//输出父类的name
//相同方法同理，但父类的私有方法无法使用super调用
}

注意点

super调用父类构造方法必须在构造方法的第一个
super必须只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法

方法重写

需要继承关系，子类重写父类的方法

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小：public>Protected>Defaulted
抛出的异常：范围可以被缩小，但不能扩大

父类的引用指向了子类：创建父类对象使用子类对象实例化，从而可以调用子类重写方法

father f=new son();

//无法重写的类型：

static方法：属于类，不属于实例
final 常量
private方法

15. instanceof 和类型转换

instanceof：判断是否有关系

//Object>Person>Teacher
//Object>Person>Student
Object object= new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false

类型转换： 父  子
//高              低
Person obj=new Student();
/student将这个对象转换为Student类型们就可以使用Student类型的方法
//((Student) obj)将父类强行转换为子类

Student student=new Student();
Person person=student;
//子类转换为父类可能丢失自己本来的一些方法

16. STATIC

静态变量：直接用类可以调用
静态方法：可以被类中的普通方法调用，但静态方法不能调用普通的类
静态代码块：
static{ } ：首先加载

17. 抽象类

abstract关键字

抽象类里只定义方法，只有名字，没有实现也不能new
抽象类的方法子类都必须实现
抽象类中可以写普通的方法
抽象方法必须写在抽象类中

18. 接口

implements
interface关键字代替class
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！自己无法写方法~专业的约束

接口里所有定义都是抽象的public
实现了接口的类必须重写接口中的所有方法
接口可以多继承，用逗号隔开即可

19. 内部类

类的里面再写一个类

public class Outer{

public void out(){}

class Inner{ 
public void in(){} 
}
}

//通过外部类实例化内部类
Outer.Inner=outer.new Inner();
inner.in();

内部类可获的外部内的私有属性，方法

//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}

class Apple{
public void eat(){}
}
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();

20. 异常

try{
//try监控区域
}catch{
//异常时捕获异常

}finally{
//处理善后工作:释放和关闭资源
}

//主动抛出异常
if(a==0){
throw new ArithmeticException();}
public void main() throws ArithmeticException{}

//自定义异常类 extends Exception

eight-sasagawa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础复习笔记

JAVA基础1. 注释1.单行注释：//2.多行注释：/* /3.文档注释/***/2. 数据类型long num1=10L;//用大写L，防止l看成1float num2=20.1f;char name ='国';boolean flag=true; //boolean flag=false;1. 整数拓展二进制0b八进制0十六进制0x2. 浮点数拓展//float 有限离散舍入误差接近但不等于//最好完全避免使用浮点数进行比较//BigDeci
复制链接

扫一扫