Java基础复习

最新推荐文章于 2024-10-09 11:13:12 发布

煦煦向前

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量115

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_43803950/article/details/113661594

版权

Java基础复习

以下内容来自于视频学习的笔记: 狂神说Java.
IDEA 快捷键

Ctrl+Alt+L 自动对齐代码
Ctrl + D 复制当前行到下一行
Alt+Enter 自动排错，没有的包可以自动导入
Ctrl+鼠标点击方法，可以跳转
Alt+Insert 自动生成构造器,get，set方法
Ctrl+H 光标在某个类里时，使用快捷键，右侧会生成类树
Ctrl+Alt+T 在需要包裹的代码处，可以选择包裹方式，比如生成try catch

注释
- 单行注释 //
- 多行注释 /* */
- 文档注释
标识符

类名、变量名以及方法名都被称为标识符。以字符、美元符号或下划线开始

，首字母之后可以是字母、美元符号、数字或者下划线的组合，标识符大小写敏感

可以使用中文，但是最好不要

关键字如下图：

数据类型

基本类型：数值类型（整数类型[byte一个字节、short两个字节、int四个字节、long八个字节]、浮点类型[float四个字节、double八个字节]、字符类型[char两个字节]）、boolean类型（一个字节，值只有true和false）

//整数
int num1 = 10; //最常用
byte num2 = 20; 
short num3 = 30;
long num4 = 30L; //Long类型要在数字后加个L
//小数：浮点数
float num5 = 50.1f; //float型要在后边加F,不然double
double num6 = 3.23333333;
//字符
char name = 'A';
//字符串，String不是关键字，类
//String name = '哆啦梦'
//布尔值
boolean flag = true;
//boolean flag = false;

引用类型：类、接口、数组

类型转换
- 强制转换（类型）变量名高–>低
- 自动转换低 -->高
  
  注意：1.不能对布尔值进行转换
  
  2.不能把对对象类型转换为不相干的类型
  
  3.转换的时候可能存在内存溢出，或精度类型
- 补充：JDK7特性，数字之间可以用下划线分隔，不影响
```
int mone = 1_0000_0000;//下划线分隔
int year = 20;
//先把一个数转换为long型，避免溢出
long total = (long)money * year ;
```
变量
- 每个变量必须声明其类型，基本类型或引用类型
- 命名：首字母小写和驼峰原则
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域（类变量、实例变量、局部变量）
  - 实例变量：从属于对象，如果不自行初始化，则为这个类型的默认值（bool类型默认值false，除了基本类型，默认类型为null）
常量

修饰符（下图紫色部分）不区分顺序
```
static  final double PI = 3.14;
```
常量命名：一般大写字符和下划线：MAX_VALUE

补充：
- 类名：首字母大写和驼峰原则：Man,GoodMan
- 方法名：首字母雄安写和驼峰原则
- 包名：小写

运算符 [使用括号区分优先级]

算术运算符包括自增、自减

//补充连接符号 + 只要加号的内容出现字符串类型，则变成字符串拼接
int a = 1;
int b = 2;
System.out.println(a+b+'');//输出3
System.out.println(''+a+b);//输出12

赋值运算符
关系运算符返回结果为bool值

逻辑运算符： && 、||、~、<<左移x2，、>>右移x2

boolean a = true;
boolean b = false;
System.out.println("a && b "+(a&&b));//逻辑与运算
System.out.println("a || b "+(a||b));//逻辑或运算
System.out.println("！(a && b) "+!(a&&b));//逻辑非运算
//注意&&与如果第一个错了，则后边不执行；||同理

位运算符

条件运算符？：

//x?y:z
int score = 80;
String type = score<60?"不及格":"及格";
System.out.println(type);

拓展运算符

补充：幂运算

double pow = Math.pow(2,3);
System.out.println(pow);

包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
- 包语句的语法格式为：package pkg1[.pkg2[.pkg3…]];
- 一般利用公司域名倒置作为包名：www.baidu.com com.baidu.www
- 为了能够使用某个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句可完成此功能
```
import package1[.package2...].(classname|*);
//注意加分号
```

JavaDoc

javadoc命令是用来生成自己的API的

/**
@author:
@version:
@since: 指明需要最早使用的jdk版本
@param: 参数名
@return:返回值情况
@throws:异常抛出情况
*/

使用cmd生成文档

//在左侧目录需要生成文档的类，右键->Show in Explorer->导航栏打开cmd

javadoc -encoding UTF-8 -charset UTF-8 Doc.java
回到文件管理器，出现了.html文件即为生成的文档

```

也可使用IDEA生成javaDoc文档

Tools -> Generate JavaDoc->选择要生成文档的File->选择生成文档的输出目录Ouput directory ->选择Locale：zh_CN->传入JavaDoc的参数，一般写成： -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

然后找到生成的html

Java流程控制

Scanner对象实现程序和人的交互，可以通过Scanner类获取用户输入

Scanner s = new Scanner(System.in);

通过Scanner类的next()和nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

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

Scanner scanner = new Scanner(System.in);//程序会等待用户输入结束
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if(scanner.hasNext()){
    //
    String str = scanner.next();//
    System.out.println("输出的内容为"+str);
}
//凡是属于IO流的类如果不关闭会占用资源，用完就关闭
scanner.close();

nextLine():
以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
可以获得空格。

Scanner scanner = new Scanner(System.in);//程序会等待用户输入结束
System.out.println("使用nextLine方式接收：");
//判断用户有没有输入字符串
if(scanner.hasNextLine()){
    //
    String str = scanner.nextLine();//
    System.out.println("输出的内容为"+str);
}
//凡是属于IO流的类如果不关闭会占用资源，用完就关闭
scanner.close()

顺序结构
- JAVA的基本结构是顺序结构

选择结构

if单选择结构

Scanner scanner = new Scanner(System.in);
Stirng s = scanner.nextLine();
if(s.equals("hello")){
    System.out.println("End");
}

if双选择结构

if(布尔表达式){
    
}else{
    
}

if多选择结构

if(布尔表达式){

}else if(){
   
}else{
   
}

if嵌套结构

switch多种选择结构

switch case语句判断一个变量与一系列值中某个值是佛相等，每个值称为一个分支；
表达式可以是byte、short、int、char类型，从JDK7开始，可以是字符串

switch(expression){
    case value1:
        //语句
        break;//可选
    case value2:
        //语句
        break;//可选
    // 可以有任意数量的case语句
    default: //可选
        //语句       
        
}

反编译

P37后半部分

从project结构中，找到文件生成的class文件的位置，从文件夹中复制该class文件到源代码位置。

循环结构

while循环

- while(布尔表达式){

   //循环内容
 
}

for 循环

for(初始化；布尔表达式；更新){
    //代码
}
//在IDEA中，输入100.for回车,则会自动生成下面
for(int i = 0; i < 100; i++){
    
}

增强for 循环

int[] numbers = {0,20,30,40,50}; //定义一个数组
//遍历数组元素
for(int x:numbers){
    System.out.println(x); //这样会输出数字钟每一个元素
    
}

do–while循环
```
do{
       
}while(布尔表达式);
```

break & continue

break跳出循环，continue 终止本次循环

方法

方法是语句的集合，他们一起执行一个功能

修饰符(可选) 返回值类型 方法名(参数类型 参数名){
    方法体
     return 返回值
}

方法调用：调用方法：
- 对象名.方法名（）
方法的重载
- 方法名称必须相同，参数列表必须不同
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载
命令行传参

P48
可变参数
- 方法声明中，在指定参数类型后加一个省略号(…)
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何不同的参数必须在它之前声明。
```
public void test(int...i){
    //调用时，可以输入参数整数，如下但因输入的第一个整数
    System.out.println(i[0]);
}
```
递归
- 方法自己调用自己
- 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环

数组

相同类型数据的有序集合

可以通过下标访问

int[] nums;//1.声明一个数组
nums = new int[10];// 2.创建一个数组
nums[0] = 1; //3.给数组元素赋值，如果不赋值，则为对应类型的默认值
//获取数组长度：arrays.length

初始化方法
- 静态初始化：创建+赋值
```
int[] a = {1,2,3};
```
- 动态初始化
```
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
```
- 数组默认初始化
  
  数组时引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量童颜给的方式被隐式初始化

数组的基本特点

- 长度确定，数组一旦被创建，它地打小就不可改变
- 元素是相同类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组本身就是对象，Java对象是在堆中地，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组的使用
- For-循环
- 数组作方法入参
- 数组作返回值

多维数组

//二维数组为例
int[][] array = {{1,2},{2,3},{3,4}};
for(int i=0;i<array.length;<i++){
    for(int j = 0;j<array[i].length;j++){
        System.out.println(array[i][j]);
    }
}

Arrays类

import java.util.Arrays;
//打印数组元素 Arrays.toString()
int[] a = {1,2,4,3,9090};
System.out.println(Arrays.toString(a)); 
//会打印出[1, 2, 4, 3, 9090]
//Arrays.sort(数组名) 对数组进行排序
Arrays.sort(a);
Arrays.toString(a); //排序后输出为[1, 2, 3, 4, 9090]

给数组赋值：fill方法
数组排序：sort方法，升序
比较数组：通过equals方法比较数组中元素值是否相等
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法

冒泡排序

//从大到小
public static int[] sort(int[] array){
    int temp = 0;
    
    //外层循环，判断轮数
    for(int i = 0; i<array.length-1; i++){
        //内层循环，比较判断两个数
        for(int j =i; j< array.length-2-i;j++){
			if(array[j+1]>array[j]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }            
        }
    }
    return array;
    
}

稀疏数组

稀疏数组的处理方式：
- 记录数组移动有几行几列，有多少个不同的值
- 把具有不通知的元素和行列及值记录在一个小规模的数组中中，从而缩小程序的规模
面向对象
面向对象

以类的方式组织代码，以对象的方式的组织（封装）数据
三大特性
- 封装
- 继承
- 多态

静态方法 static 非静态方法

类名.方法名可调用静态方法

如果为非静态方法，需要先实例化一个对象

public class Student{
    //非静态方法
    public void say(){
        System.out.println("学生说话");
    }   
}
Student student = new Student();
student.say();

//加上static后，可以直接Student.say()调用

Java是值传递
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- 对象是抽象概念的具体实例

创建与初始化对象

使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
- 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void

public class Person{
    //一个类即使什么都不写，它也会存在一个方法
    //显式地定义构造器
    String name;
    //实例化初始值
    //使用new关键字，本质在构造器
    //用来初始化值
    public Person(){
        //this.name = "小鱼儿";
    }
    //有参构造：一旦定义了有参构造，无参就必须显式构造
    //如果没有有参构造，可以自动生成隐式无参构造
    public Person(String name){
        this.name = name;
    }
}

封装

“高内聚、低耦合”

通常，应禁止直接访问一个对象中数据地实际表示，而应通过操作接口来访问，这称为信息隐藏

提高程序地安全性，保护数据
统一接口，提高系统可维护性

属性私有，get/set

public class Student{
    //属性私有，无法直接实例名.属性来更改
    //名字
    private String name;
    //学号
    private int id;
    //姓名
    private char sex;
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    
}

继承
- 本质是对某一批类地抽象，从而实现对现实世界更好建模
- extends,子类是父类地扩展
- JAVA类中只有单继承，没有多继承
```
//定义Person类，Student类是Person类的子类
public class Student extends Person{
       
}
```
public protected default private
在Java类中，所有的类都默认直接或者间接继Object类
Super
- super调用父类的构造方法必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
super和this
- 代表的对象不同： this:本身调用者这个对象
  
  super:代表父类对象的应用
  - 前提： this没有继承也可以使用
    
    super:只能在继承条件才可以使用
  - 构造方法： this():本类的构造
    
    super()：父类的构造
方法的重写
- 重写需要有继承关系，子类重写父类的方法
- 参数列表必须相同
- 修饰符：范围可以扩大，public>Protected>Default>private
- 抛出的异常：范围，可以被缩小，但不能扩大
- 重写都是方法的重写，与属性无关
- 非静态方法，才叫重写，而且需要public
多态

即同一方法可以根据发送兑现给的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类、有关系的类）。
```
//一个对象的实际类型是确定的
new Student();
new Person();
//可以指向的引用类型不确定了，父类的引用指向子类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
//对象能执行的方法，主要看对象左边的类型
```
- 多态是方法的多态，属性没有多态
- 父类和子类，要有联系。
- 存在条件：继承关系，子类重写父类方法，父类引用指向子类对象

instanceof

System.out.println(X instanceof Student);
//能否编译通过取决于X和Y之间是否有父子关系

子类转化为父类，可能丢失一些方法

static

静态属性

public class Student{
    private static int age;//静态的变量 多线程！
    private double score;//非静态的变量
    
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println(Student.age);//建泰属性直接使用类名调用即可
        System.out.println(s1.age);//非静态属性实例化后
        System.out.println(s1.score);
    }
    
}

静态方法

抽象类
```
//抽象类 ，单继承
public abstract class Action{
    //约束 
    public abstract void doSomething();
    
}
```
- 不能new这个抽象类，只能靠子类去实现它：约束
- 抽象类中可以写普通的方法~
- 抽象方法必须要在抽象类中~
接口

普通类：只有具体实现

抽象类：具体实现和规范(抽象方法)都有！

接口：只有规范。约束和实现分离：面向接口编程

声明接口的关键字是interface

接口中的所有定义其实都是抽象的public abstract
```
public interface UserService{
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String naem);
}
```
定义接口后，写它的实现
```
//类实现接口，implements 接口
//实现接口中的类，就需要实现其中的方法
public class UserServiceImpl implements UserService{
    
}
//利用接口实现多继承
```
接口的作用：1.约束 2.定义一些方法，便于分工
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口

内部类

就是在一个类的内部再定义一个类，比如A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类.

比如

public class Outer{
    private int id;
    public void out(){
        System.out.println("这是外部类的方法")；
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

成员内部类
静态内部类
局部内部类
匿名内部类

异常
- 异常处理五个关键字：try、catch、finally、throw、throws
- Error和Exception:Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能地去处理这些异常。
```
int a = 1;
int b = 0;
try{//try监控区域
    System.out.println(a/b);
}catch(ArithmeticException e){
    System.out.println("程序出现异常，变量b不能为0");}finally{//处理善后工作
    System.out.println("finally");   
}
//finally 可以不要finally
```

自定义异常

public class MyException extends Exception{
	
}

煦煦向前

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

Java基础 复习

Java基础 复习

Java流程控制

面向对象

Java基础复习

Java基础复习