狂神说Java--Java学习笔记(基础合集)

最新推荐文章于 2024-05-08 00:19:50 发布
最新推荐文章于 2024-05-08 00:19:50 发布
阅读量2k 收藏 33
点赞数 7
文章标签： java windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42186847/article/details/120633189
版权

笔记参考来源狂神说Java视频https://www.bilibili.com/video/BV12J41137hu
本篇笔记有点长，可以根据目录定位，建议配合视频学习。

预科

什么是计算机

  1. 名称：Computer，全称电子计算机，俗称电脑。
  2. 定义：能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。
  3. 组成：由硬件和软件组成。
  4. 形式：常见显示有台式计算机、笔记本计算机、大型计算机等。
  5. 应用：科学计算、数据处理、自动控制、计算机辅助设计、人工智能、网络等领域。

硬件及冯诺依曼结构

计算机硬件

组成：CPU，主板，内存，电源，主机箱，硬盘，显卡，键盘、鼠标，显示器。

冯诺依曼结构

在这里插入图片描述

软件及软件开发

计算机软件

Windows常用快捷键

Alt+f4关闭窗口 Shift+Delete永久删除 ctrl+w自动保存

死机：任务管理器结束进程

基本的Dos命令

打开CMD的方式

  1. 开始+系统+命令提示符
  2. win键+R+输入cmd (推荐使用)
  3. 在任意的文件夹下，按住Shift键+鼠标右击，打开命令行窗口
  4. 在资源管理器地址栏路径前面加 “cmd ”
  5. 管理员运行方式：命令提示符右键以管理员身份运行（最高权限运行）

常用的Dos命令

# 盘符切换 E:
# 查看当前目录下所有文件 dir
# 切换目录 cd /d E:\idea
# 返回上一级目录 cd ..
# 进入同级目录下的下一级目录 cd tmp(该目录下的文件名)
# 清屏 cls (clear screen)
# 退出终端 exit
# 查看电脑当前IP地址 ipconfig

# 打开计算器 calc
# 打开画图 mspaint
# 新建记事本 notepad

# 在当前目录新建文件夹 md test(文件夹名)
# 新建文件 cd> a.txt(文件名)
# 删除文件 del a.txt(文件名)
# 删除目录 rd test(目录名)

# ping命令(复制链接进入Dos直接单击鼠标右键粘贴)
	ping www.baidu.com

计算机语言发展史

  • 第一代语言：机器语言
  • 第二代语言：汇编语言
  • 第三代语言：高级语言

高级语言

C、C++、Java、C#、Python、PHP、JavaScript …

大体上分为：面向过程与面向对象两大类

  • C语言是典型的面向过程的语言，C++，Java是典型的面向对象的语言

Java入门

Java帝国的诞生

在这里插入图片描述

在这里插入图片描述

Java特性与优势

  • 简单性
  • 面对对象
  • 可移植性
  • 高性能
  • 分布式
  • 多态性
  • 多线程
  • 安全性
  • 健壮性

Java三大版本

  • Write Once，Run Anywhere

  • JavaSE: 标准版 (桌面程序，控制台开发…)

  • JavaME: 嵌入式开发 (手机，小家电…)，已经凉了

  • JavaEE: E企业级开发 (Web端，服务端开发…)，JavaSE为基础

JDK JRE JVM

  • JDK：Java Development Kit (Java开发者工具，包括 JRE，JVM)
  • JRE：Java Runtime Environment (Java运行时环境)
  • JVM：Java Virtual Machine (Java虚拟机，跨平台核心)

img

安装开发环境

卸载JDk

  1. 删除Java安装目录
  2. 删除环境变量JAVA_HOME
  3. 删除path下关于JAVA的目录
  4. Java -version

安装JDK

  1. 百度搜索JDK8，找到下载地址
  2. 同意协议，下载电脑对应的版本，如64位操作系统下载 jdk-8u281-windows-x64.exe
  3. 双击安装JDK
  4. 记住安装路径
  5. 配置环境变量
    1. 我的电脑-》属性-》系统高级设置-》环境变量
    2. 系统变量 新建–> JAVA_HOME 输入对应的jdk安装路径
    3. path变量–>% JAVA_HOME%\bin
  6. 测试是否成功 cmd–>Java -version

Java基础

注释

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

标识符和关键字

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

关键字

在这里插入图片描述

标识符注意点

  • 所有标识符都应该以 字母、$(美元符)、_(下划线) 开头
  • 首字母之后可以是 字母、$、_ 或数字任何字符组合
  • 关键字不能作为变量名或方法名
  • 标识符大小写敏感
  • 可以用中文命名，但不建议使用，即使用拼音命名也Low

数据类型

  • 强类型语言

    • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

  • 弱类型语言：JavaScript，Python

  • Java的数据类型分为两大类

    • 基本类型（primitive type），有8大基本类型，此外都是引用类型
    • 引用类型（reference type）

在这里插入图片描述

//整数
int num1 = 10; //最常用，只要别超过21亿（2^31-1）
byte num2 = 20; //-128~127
short num3 = 30;
long num4 = 30L; //long类型数字后面要加个L(尽量用大写，小写l容易与1搞混)


//小数：浮点数
float num5 = 50.1F; //float类型数字后面要加个F
double num6 = 3.141592653589793238;


//小数：浮点数
float num5 = 50.1F; //float类型数字后面要加个F
double num6 = 3.141592653589793238;


//布尔值：是非
boolean flag = true

类型转换

  • 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
  • 容量高–>低：

在这里插入图片描述

  • 运算中，不同类型的数据先转化位同一类型，再进行运算。
    • 强制转换，（类型）变量名，容量由高到低
    • 自动转换，容量由低到高
//强制转换 （类型）变量名 高--低
//自动转换 低--高
int i = 128;
byte b = (byte)i; //强制转换 内存溢出 -128~127
double d =i; //自动转换

System.out.println(i); //128
System.out.println(b); //-128
System.out.println(d); //128.0
/*
   注意点：
   1.不能对布尔值进行转换
   2.不能把对象类型转换为不相干的类型
   3.在把高容器转换到低容量的时候，强制转换
   4.可能存在内存溢出，或者精度问题
 * */
System.out.println((int)23.7); //23 丢失精度
char c = 'a';
int n = c+1;
System.out.println(n); //98
System.out.println((char)n); //b


//当操作数比较大时，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000; //10亿，下划线不会被打印出来
System.out.println(money); //1000000000
int years = 20;

int total = money*years;  //数据大，溢出
System.out.println(total); //-1474836480

long total2 = money*years; //默认是int，转换前就有溢出问题
System.out.println(total2); //-1474836480

long total3 = money*(long)years; //先把一个数转Long
System.out.println(total3); //20000000000

变量、常量、作用域

  • 变量是什么：就是可以变化的量

  • Java是一种强类型语言，每个变量都必须声明其类型

  • Java变量是程序中最基本的存储单元，要素包括变量名，变量类型和作用域

    //数据类型 变量名 = 值;
type varName [=value][{,varName[=value]}];
//可以使用逗号隔开同多个类型的变量，但不建议在一行定义多个变量

变量作用域

  • 类变量（static）
  • 实例变量
  • 局部变量
public class Variable{    static int 	allClicks = 0; //类变量    String str = "hello world"; //实例变量    public void method(){        int i=0; //局部变量    }}

常量

  • 常量：初始化后不能再改变的值，不会变动的值。

  • 可以理解为一种特殊的变量，其值被设定后，在程序运行过程不允许被更改。

    //常量一般用大写字符final 常量名=值;final double PI=3.14;

    //修饰符 不存在先后顺序，static可以写final后面static final doube PI=3.14; //类变量，该类下的全局范围

变量的命名规范

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写+驼峰原则：lastName
  • 局部变量：首字母小写+驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写+驼峰原则：Man，GoodMan
  • 方法名：首字母小写+驼峰原则：run()，fastRun()

运算符

在这里插入图片描述

int a=10;int b=20;System.out.println(a/b); //0System.out.println((double)a/b); //0.5long c=12300000000;System.out.println(a+b); //intSystem.out.println(a+c); //long 自动转换式子中容量大的数据类型

自增自减运算符

// ++自增 --自减 单目运算符int a = 3;int b = a++; //b=a,a=a+1 先赋值 即b=3 a=4int c = ++a; //a=a+1,c=a 先自增 即a=5 c=5System.out.println(a); //5System.out.println(b); //3System.out.println(c); //5

//幂运算 2^3 2*2*2=8double pow = Math.pow(2,3); // (底数，指数)double型System.out.println(pow); //8.0

//扩展：笔试题 i=5 s=(i++)+(++i)+(i--)+(--i) s=?int i=5;int s=(i++)+(++i)+(i--)+(--i);System.out.println(s); //24

逻辑运算符

  • && 逻辑与运算：两个变量都为真，结果为true
  • || 逻辑与运算：两个变量有一个为真，结果为true
  • ! 取反，真变为假，假变为真
// 与(snd) 或(or) 非(取反)
boolean a = true;
boolean b = false;

System.out.println(a&&b); // false
System.out.println(a||b); // true
System.out.println(!(a&&b)); // true

int c=5;
boolean d = (c<5)&&(c++<5); //第一个值为false，后面就不进行判定了
System.out.println(d); //false
System.out.println(c); //5 c++未执行

位运算

/*
    A = 0011 1100
    B = 0000 1101

    A&B 0000 1101 按位与
    A|B 0011 1101 按位或
    A^B 0011 0001 异或
    ~B  1111 0010 非

    面试题：2*8 怎么算最快？ 2<<3
    <<左移  *2 效率极高！！
    >>右移  /2
   */
System.out.println(2<<3); // 16

三元运算符

int a = 10;int b = 20;a+=b; // a = a+ba-=b; // a = a-bSystem.out.println(a); //10//字符串连接符 + ，转化为String类型,然后拼接    注意！！System.out.println(""+a+b); //1020System.out.println(a+b+""); //30 先进行运算，再转为String拼接System.out.println(a+b+"str"); //30str

// x ? y : z//如果x为真，则结果为y,否则为z//if(x) y; else z;int score = 80;String type = score<60?"及格":"不及格";System.out.println(type); //及格

包机制

  • 为了更好地组织类，Java提供了包机制，由于区分类名的命名空间
  • 包的语法格式：
package pkg1[.pkg2[.pkg3...]];
  • 一般利用公司域名倒置作为包名；com.kuangstudy.www
  • 为了能够使用一个包的成员，需要在Java程序中导入该包
import package1[.package2...].(className|*); //通配符* 导入包下所有的类
  • 参考：阿里巴巴Java开发手册

JavaDoc生成文档

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

  • 参数信息

    • @author 作者名
    • @version 版本号
    • @since 指明最早用的jdk版本
    • @param 参数名
    • @return 返回值情况
    • @throws 异常抛出情况

  • API文档：https://docs.oracle.com/javase/8/docs/api/

/**
 * @author Kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Demo05 {
    String name;

    /**
     * @author kuangshen
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    
}
  1. 打开某个类所在文件夹下的cmd命令行
  2. 输入：javadoc -encoding UTF-8 -charset UTF-8 Doc(类名).java
  3. 会自动生成该类有关的API文档，查看文件夹发现多了一些文件
  4. 打开 index.html（首页）查看文档注释

Java流程控制

用户交互Scanner

Scanner对象

  • 之前我们学的基本语法并没有实现程序和人的交互，Java给我们提供了一个工具类，可以获取用户的输入java.util.Scanner是Java5的新特征，我们通过Scanner类来获取用户的输入。

  • 基本语法

    Scanner s = new Scanner(System.in);

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

    //创建一个扫描器对象
Scanner scanner = new Scanner(System.in);

System.out.println("使用next方式接收");
//判断用户有没有输入字符串
if(scanner.hasNext()){  //使用hasNextLie()会接收一行 "hello word"
    //使用next方式接收
    String str = scanner.next(); 
    System.out.println("输入的内容为："+str);
    //input: hello word
    //输入的内容为：hello
}
//凡是属于IO流的类如果不关闭会一直占用资源
scanner.close();

next（）：

  • 一定要读取到有效字符后结束输入
  • 对输入有效字符之前遇到的空白，next（）方法会自动将其去掉
  • 只有输入有效字符后才能将后面输入的空白作为分隔符或者结束符
  • next（）不能得到带有空格的字符串
Scanner scanner=new Scanner(System.in);
System.out.println("你输入的是：");
String str=scanner.nextLine();
System.out.println("输出："+str);
scanner.close();

nextLine():

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

Scanner进阶

判断scanner是否输入的正确

Scanner scanner=new Scanner(System.in);
int i=0;
System.out.println("请输入整数:");
if (scanner.hasNextInt()){
    i = scanner.nextInt();
    System.out.println("你输入的没错:" + i);
}else{
    System.out.println("请输入整数");
}

Scanner sanner=new Scanner(System.in);
float a=0.0f;
System.out.println("请输入小数:");
if (scanner.hasNextFloat()){
    a = scanner.nextFloat();
    System.out.println("你输入的是小数没错:" + a);
}else{
    System.out.println("请输入小数");
}
scanner.claose();

例题：我们可以输入多个数字，并求其总和和平均数，每输入一个数字回车确认，通过输入非数字来结束输入并输出执行结果

 Scanner scanner=new Scanner(System.in);
float f=0.0f;
float sum=0.0f;
float avg=0.0f;
System.out.println("请输入多个数字：");
while (scanner.hasNextFloat()){
    f=scanner.nextFloat();
    sum=sum+f;
    avg++;
    System.out.println("你输入了第"+avg+"数字");
}
System.out.println("一共有"+avg+"个数字，"+"和为"+sum+"，平均数为："+sum/avg);
scanner.close();

switch选择结构

多选择结构还有一个实现方式就是switch case语句

switch语句中的变量类型可以是：

  • byte、short、int或者char
  • 从Java SE7开始
  • switch支持字符串String类型了
  • 同时case标签必须为字符串常量或字面量
char grade='C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            default:
                System.out.println("未知等级");
        }

switch可以支持字符串

String str="world";
        switch (str){
            case "hello":
                System.out.println("你好");
                break;
            case "world":
                System.out.println("世界");
                break;
            default:
                System.out.println("java");
                break;
        }

循环结构

  • while循环
//计算1+2+3+...+100
int i=0;
int sum=0;
while(i<100){
    i++;
    sum+=i;
}
System.out.println(sum); //5050
  • do……while循环
//先执行后判断，至少执行一次
do{
    i++;
    sum+=i;
}while(i<100) //跟上面效果一样
  • for循环
//（初始化;条件判断;迭代）
for(int i=0;i<100;i++){
    i++;
    sum+=i;
}
for(; ; ){...} //死循环
  • 九九乘法表
 for (int i=1;i<=9;i++){
            for (int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
  • 输出1-1000能被5整除的数，每行输出3个
//练习：输出1-1000能被5整除的数，每行输出3个for (int i = 1; i <= 1000; i++) {    if(i%5==0){        System.out.print(i+"\t"); //输出完不换行    }    if(i%(3*5)==0){        System.out.println();    }}
  • 死循环
//（初始化;条件判断;迭代）for(int i=0;i<100;i++){    i++;    sum+=i;}for(; ; ){...} //死循环
  • break & continue

  1. break可用在任何循环的主体部分，由于强行退出循环，也可以用在switch语句。

  2. continue用于循环语句中，终止某次循环过程，跳过剩余语句，之间进行下一次循环条件判断。

  3. 标签：后面跟一个冒号的标识符 label：

  • 增强for循环
 int []num={10,12,45,31,2,12};        for (int i=0;i<6;i++){            System.out.println(num[i]);        }        System.out.println("===================");        for (int x: num){            System.out.println(x);        }

增强for循环可以进行简写，简单方法：如果要循环5次，可以“5.for”就可以在idea中使用

  • 打印三角形
 for (int i = 0; i < 6; 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();        }

Java方法详解

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

  • 方法是解决一类问题的步骤的有序结合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

设计方法的原则：方法的本意是代码块，就是实现某个功能的语句块。我们设计方法的时候，最好保持方法的原子行，就是一个方法只完成1个功能，这样利于我们后期的扩展。

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一班情况下，定义一个方法包含以下语法：

  • 方法包含一个方法头和一个方法体。下面是一个方法的所有部分

    • 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法，定义了该方法的询问类型

    • 返回值类型：方法可能会返回值，returnValueType是返回值的数据类型，有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType是关键字void

    • 方法名：是方法的实际名称、方法名和参数共同构成方法签名

    • 参数类型参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型、顺序和参数的个数，参数是可选的，方法可以不包含任何参数

      //main方法
    public static void main(String[] args) {
        
        //实际参数：实际调用传递给他的参数
        int sum=add(5,5);
        
        System.out.println(sum);
    }

    //加法
    //形式参数，用来定义作用的
    public static int add(int a,int b){
        return a+b;
    }

    • 方法体：方法体包含具体的语句定义该方法的功能

      修饰符 返回值类型（void不返回） 方法名（参数类型 参数名）{
		···
  	方法体
    ···
    return 返回值;
}

    Java是值传递

方法的重载

  • 重载就是在一类中，有相同的函数名称，但形参不同的函数

  • 方法的重载的规则

    • 方法名称必须相同
    • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
    • 方法的返回类型可以相同也可以不相同
    • 仅仅返回类型不同不足以成为方法的重载

  • 实现理论：

    方法名称相同时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，已选择对应的方法 ，如果匹配失败，则编译器报错

命令行传参

  • 有时候希望运行一个程序时再传递给它消息。这要靠传递命令行参数给main（）函数实现
public static void main(String[] args) {    //args.length 数组长度    for (int i = 0; i < args.length; i++) {        System.out.println("args["+i+"]: "+args[i]);    }}

找到当前类的文件夹，打开cmd

在这里插入图片描述

可变参数

  • Jdk1.5开始，Java支持传递同类型的可变参数给一个方法。
  • 在方法声明中，在指定参数类型后加一个省略号 (…)。
  • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。
public static void main(String[] args) {
  //调用可变参数的方法
        printmax(34,45,456,4,6545,44,54,4,54);
        printmax(new double[]{1,2,3});
   }
   public static void printmax(double ...numbers){
       if (numbers.length==0){
           System.out.println("No argument passed");
           return;
       }

       double result=numbers[0];

       //找最大值
       for (int i=1;i<numbers.length;i++){
           if (numbers[i]>result){
               result=numbers[i];
           }
       }
       System.out.println("The max value is "+result);
   }

计算器的实现

public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入第一个数值:");
        while (scanner.hasNextDouble()){
            double a=scanner.nextDouble();
            System.out.println("请输入操作符");
            String str=scanner.next();
            System.out.println("请输入第二个数值：");
            double b=scanner.nextDouble();
            switch (str){
                case "+":
                    add(a,b);
                    break;
                case "-":
                    mius(a,b);
                    break;
                case "*":
                    multiply(a,b);
                    break;
                case "/":
                    except(a,b);
                    break;
                default:
                    System.out.println("输入的运算符错误");
                    break;
            }
        }
        }
        public static void add(double num1,double num2){
            System.out.println(num1+num2);
        }
        public static void mius(double num1,double num2){
            System.out.println(num1-num2);
        }
        public static void multiply(double num1,double num2){
            System.out.println(num1*num2);
        }
        public static void  except(double num1,double num2){
            if (num2==0){
                System.out.println("分母不能为0");
            }else{
                System.out.println(num1/num2);
            }

        }

Java中的数组

数组的简单实现

  • 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

    datatype [] arrayRefVar;int [] num1;

  • Java语言使用new操作符来创建数组，语法如下：

    datatype [] arrayRevVar=new dataType[arraySize];

  • 数组的元素是通过索引访问的，数组索引从0开始

  • 获取数组长度：array.length

     //变量的类型 变量的名字=变量的值；    //数组类型    public static void main(String[] args) {        int [] nums;//1.声明一个数组        nums=new int[10];//2.创建一个数组        int [] nums2=new int[10];//声明和创建可以放在一起        //3.给数组元素赋值        nums[0]=1;        nums[1]=2;        nums[2]=3;        nums[3]=4;        nums[4]=5;        nums[5]=6;        nums[6]=7;        nums[7]=8;        nums[8]=9;        nums[9]=10;        //计算所有元素的和        int sum=0;        for (int i = 0; i < nums.length; i++) {            sum+= nums[i];        }        System.out.println(sum);    }

数组的初始化

//静态初始化：创建+赋值int [] a={4,1,2,3,5,4,6,4};System.out.println(a[0]); //动态初始化 int [] b=new int[10]; b[0]=10; System.out.println(b[0]);

数组的四个基本特点

  • 其长度是确定的。数组一旦被创建，它的大小就是不可以改变 的
  • 其元素必须是相同类型，不允许出现混合类型
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  • 数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论原始类型还是其他对象类型，数组对象本身是在堆中。
  • ArrayIndexOutOfBoundsException：数组下标越界异常

数组使用

  • 普通的for循环
int [] arrays={1,2,3,45,5};        int sum=0;        for (int i=0;i< arrays.length;i++){            sum+=arrays[i];            System.out.println(arrays[i]);        }
  • for—Each循环（增强for循环）
int [] arrays={1,2,3,45,5};       for (int ayyays:arrays){            System.out.println(ayyays);        }
  • 数组做方法入参（void作为方法入参，可以没有返回值）
int [] arrays={1,2,3,45,5};printArray(arrays);   //打印数组元素    public static void printArray(int[] arrays){        for (int i=0;i< arrays.length;i++){            System.out.print(arrays[i]+" ");        }    }

  • 数组作返回值（反转数组）

    int [] arrays={1,2,3,45,5};int [] reverse= reverse(arrays);for (int i=0;i< reverse.length;i++){            System.out.println(reverse[i]);        }//反转数组    public static int[] reverse(int [] arrays){        int [] result=new int[arrays.length];        //反转操作        for (int i=0,j= result.length-1;i< arrays.length;i++,j--){            result[j]=arrays[i];        }        return result;    }

二维数组

  • 二维数组的遍历

     int [] [] array={{3,4},{5,6},{6,7}};//        System.out.println(array[1][1]);        //遍历二维数组的长度        for (int i=0;i< array.length;i++){            for (int j=0;j<array[i].length;j++){                System.out.println(array[i][j]);            }        }

Arrays类

  • 数组的工具类是java.utill,Arrays
  • 由于数据对象本身并没有方法可以供我们使用，但是API提供了一个工具类Arrays供我们使用
  • Array类中的方法都是static修饰的静态方法，使用时直接使用类名进行调用，可以不用对象调用
  • 常用功能
    • 给数组赋值：fill方法
    • 排序：sort方法，升序
    • 比较数组：equals方法比较数组中元素值是否相等
    • 查找数组元素：binarySearch对排序号的数组进行二分法查找操作
 int [] array={3,5,4,6,3,1,2,0,5,9,8,7};        //填充数组        Arrays.fill(array,2,4,0);        //打印数组        System.out.println(Arrays.toString(array));        //排序数组        Arrays.sort(array);        System.out.println(Arrays.toString(array));        //二分查找 返回的是值的下标        System.out.println(Arrays.binarySearch(array,0));

冒牌排序

  • 冒泡排序是八大排序最出名的排序算法。
  • 代码：两层循环，外层冒泡轮数，里层依次比较。
  • 当我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)。
public static void main(String[] args) {        int [] a={4,5,6,5,45,54,5,64,54,7};        int [] sort=sort(a);        System.out.println(Arrays.toString(sort));    }    public static int [] sort(int []array){        int temp=0;        for (int i=0;i< array.length-1;i++){//            boolean flag=true;            for (int j=0;j< array.length-i-1;j++){                if (array[j+1]<array[j]){                    temp= array[j];                    array[j]= array[j+1];                    array[j+1]=temp;//                    flag=true;                }            }//            if (flag==false){//                break;//            }        }        return array;    }

加上“//”为优化部分

稀疏数组

在这里插入图片描述

在这里插入图片描述

//创建一个二维数组 11*11 0：没有妻子 1：黑子 2：白字
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        System.out.println("输出原始的数组");

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("=================");
        System.out.println("有效值的个数 " + sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //3.遍历二维数组，将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                }
            }
        }
        //4.输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");
        }
        System.out.println("==============");
        System.out.println("还原");
        //1.读取稀疏数组
        int [][]array3=new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原他的值
        for (int i=1;i< array2.length;i++){//注意从1开始，0是头部信息
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组");

        for (int [] ints:array3){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

面向对象编程（OOP）

初始面向对象

  • 属性+方法=类

  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

  • 面现象对象比那晨光的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

  • 从认识论角度考虑是现有对象后有类。

回顾方法的定义以及调用

定义

  • main方法
 //main 方法    public static void main(String[] args) {    }/*修饰符 返回值类型 方法名（……）{    //方法体    return 返回值；    } */    public String sayhello(){        return "hello world";    }    public void print(){        return;    }    public int max(int a,int b){        return a>b ?a :b;    }
  • 方法的调用
Students students=new Students();students.say();

  • 注意值传递和参数传递

    	 public static void main(String[] args) {        Person person= new Person();        System.out.println(person.name);        Demo05.change(person);        System.out.println(person.name);    }    public static void change(Person person){        person.name="张三";    }    }class Person{    String name;//null
    • 基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的
    • 对象作为参数传递时，是对象在内存中的地址拷贝一份给了参数

类和对象的关系

  • 类是一种冲向的数据类型，它是对某一类事务整体描述/定义，但是并不能代表某一个具体的事物
  • 对象是抽象概念的具体实例

创建和初始化对象

  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象 进行默认的初始化以及对类中构造器的使用
//实例化对象Students xiaoming =new Students();        xiaoming.name="小明";        xiaoming.age=3;        System.out.println(xiaoming.name);        System.out.println(xiaoming.age);

//类public class Students {    //学生类    String name;//null    int age;//0    //方法    public void study(){        System.out.println(this.name+"在学习 ");    }}
  • 一个类即使什么都不写，它也会存在一个方法
  • 构造器：
    • 和类名相同
    • 没有返回值
  • 核心作用：
    • 使用new关键字，本质是在调用构造器
    • 构造器同来初始化值
  • 在无参构造器中，无参构造器可以实例化初始值
//无参构造器public Person（）{  }//在main方法中Person person=new Person();

注意点：

  • 有参构造器：一旦定义了有参构造，无参就必须显示定义
  • Alt+Insert

内存分析

  //类：抽象的，实例化        //类实例化会返回一个自己的对象        //student对象就是一个Students类的具体实例        Students xiaoming =new Students();        xiaoming.name="小明";        xiaoming.age=3;        xiaoming.study();        xiaoming.play();        System.out.println(xiaoming.name);        System.out.println(xiaoming.age);        Students xiaohong=new Students();        xiaohong.name="小红";        xiaohong.age=15;        xiaohong.study();        System.out.println(xiaohong.name);        System.out.println(xiaohong.age);

 //学生类    String name;//null    int age;//0    //方法    public void study(){        System.out.println(this.name+"在学习 ");    }    public void play(){        System.out.println(this.name+"在游戏中，王者荣耀");    }
  • 对象通过引用类型来操作：栈 - - ->堆

在这里插入图片描述

在这里插入图片描述

小结类与 对象

  1. 类与对象
    • 类是一个模板：抽象，对象是一个具体的实例
  2. 方法
    • 定义，通用！
  3. 对应的引用
    • 引用类型：基本类型（8）
    • 对象是通过引用来操作的 ：栈—→堆
  4. 属性：字段Field 成员变量
    • 默认初始化：
      • 数字：0 0.0
      • char u0000
      • boolean：false
      • 引用：null
    • 修饰符 属性类型 属性名=属性值！
  5. 对象的创建和使用
    • 必须使用new关键字创建对象，构造器Person xiaohong=new Person（）；
    • 对象的属性 xiaohong.name
    • 对象的方法 xiaohong.sleep()
  6. 类
    • 静态的属性 属性
    • 动态的行为 方法

封装

  • 该露的露，该藏的藏
    • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
  • 封装（数据的隐藏）
    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。
  • 属性私有，get/set
 		//名字
    private String name;

    //学号
    private int id;

    //性别
    private char sex;

    //年龄
    private int age;

    public int getAge() {
        if (age>120 || age<0){
            this.age=3;
        }else{
            this.age=age;
        }
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

 Students s1=new Students();        s1.setAge(1200);        System.out.println(s1.getAge());
  • 作用
    1. 提高程序的安全性，保护数据
    2. 隐藏代码的实现细节
    3. 统一接口
    4. 系统可维护性增加了

继承

  • 继承的本质是对某一批类的抽象，从而实现对世界更好的建模

  • extends的意思是“扩展”。子类是父类的扩展，使用extends来表示

  • Java中只有单继承，没有多继承！一个类是能继承一个父类

  • 继承是类与类之间的一种关系，此外还有依赖、组合、聚合等

  • 继承关系的两个类，一个是子类（派生类），一个是父类（基类）子类继承父类

  • 子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承。

  • 在Java中，所有类，都默认直接或间接继承Object类 (Ctrl+H 可以查看类关系)

  • 被final修饰的类，无法被继承（断子绝孙）。

super&this

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个（默认调用）
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法

VS this

  • 代表的对象不同：

    • this：本身调用者这个对象
    • super：代表父类对象的应用

  • 前提

    • this：没有继承也可以使用
    • super：只能在继承条件下可以使用

  • 构造方法

    • this（）：本类的构造
    • super（）：父类的构造

  • super与this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用。

super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

在这里插入图片描述

在这里插入图片描述

方法的重写

  • 重写：子类的方法必须与父类方法必须一致，方法体不同。
  • 参数列表必须相同
  • 修饰符可以扩大但是不可以缩小
    • public>protected>default>private
  • 抛出的异常：范围，可以被缩小，但是不能扩大：ClassNotFoundException–>Exception（大）
  • 重写是方法的重写，与属性无关
  • 重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
  • 被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写
public class B {
    public static void test(){ //静态方法
        System.out.println("B==>test()");
    }
}


public class A extends B{ //继承
    public static void test(){
        System.out.println("A==>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用之和左边定义的类型有关
        A a = new A();
        a.test(); //打印 A==>test()

        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test(); //打印 B==>test()
    }
}

修改A.Java，B.java

public class B {    public void test(){ //非静态方法        System.out.println("B==>test()");    }}public class A extends B{    @Override //重写了B的方法    public void test() {        System.out.println("A==>test()");    }}

//父类的引用指向了子类B b = new A(); //子类重写了父类的方法，执行子类的方法b.test(); //打印变成了 A==>test()/* 静态方法是类的方法，非静态方法是对象的方法有static时，b调用了B类的方法，因为b是b类定义的没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法*/

重写：子类的方法必须和父类保持一致：方法体不同

​ 被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写

为什么重写：

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

多态

  • 即同一方法可以根据发送对象的不同而采用不同的行为方式
  • 一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
  • 多态存在条件
    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e0qkJ1Og-1633573131035)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211003093902789.png)]

注意点：

  1. 多态是方法的多态，没有属性的多态
  2. 父类和子类，有联系 类型转换异常: ClassCastException
  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！

instanceof和类型转换

  • instanceof 引用类型比较，判断一个对象是什么类型

    Object object = new Student();        System.out.println(object instanceof Student);        System.out.println(object instanceof Person);        System.out.println(object instanceof Object);        System.out.println(object instanceof Teacher);        System.out.println(object instanceof String);        System.out.println("======================");        Person person = new Student();        System.out.println(person instanceof Student);        System.out.println(person instanceof Person);        System.out.println(person instanceof Object);        System.out.println(person instanceof Teacher);//        System.out.println(person instanceof String);        System.out.println("=======================");        Student student = new Student();        System.out.println(student instanceof Student);        System.out.println(student instanceof Person);        System.out.println(student instanceof Object);//        System.out.println(student instanceof Teacher);//        System.out.println(student instanceof String);

  • 类型转换

    • 父类引用指向子类的对象
    • 把子类转换为父类，向上转型，会丢失自己原来的一些方法
    • 把父类转换为子类，向下转型，强制转换，才调用子类方法
    • 方便方法的调用(转型)，减少重复的代码，简洁。

static

  • 静态变量可以直接用类名访问，也称类变量。
  • 静态变量(或方法)对于类，所有对象（实例）所共享。
  • 静态变量可以直接调用，但是非静态变量不可以直接调用
    private static int age;    private double score;        public void  run(){            }    public static void go(){            }    public static void main(String[] args) {        Student s1=new Student();        System.out.println(Student.age);//        System.out.println(Student.score);        System.out.println(s1.age);        System.out.println(s1.score);        go();//        run();    }
  • 静态区代码 加载类时一起被初始化，最早执行且只执行一次（第一次new）。
public class Person {    {        System.out.println("匿名代码块");    }    static {        System.out.println("静态代码块");    }    public Person(){        System.out.println("构造方法");    }    public static void main(String[] args) {        Person person=new Person();        System.out.println("==============");        Person person2=new Person();        System.out.println("==============");        Person person3=new Person();    }}
  • Math->随机数:
//静态导入包import static java.lang.Math.random;public class Application {    public static void main(String[] args) {        //第一种随机数，不用导包        System.out.println(Math.random()); //0.7562202902634543        //第二种随机数，静态导入包        System.out.println(random()); //0.5391606223844663    }}

抽象类

  • abstract修饰的类就是抽象类，修饰的方法就是抽象方法。

  • 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。

  • 抽象类不能使用new来创建对象，它是用来让子类继承的。

  • 抽象方法只有方法的声明，没有实现，让其子类实现。

  • 子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类。

//abstratct 抽象类public abstract class  Action {//约束，有人帮我们实现的//abstract，抽象方法，只有方法名字，没有方法的实现！    public abstract void dosomething();//abstract 抽象类 类只能单继承（接口可以多继承）        //约束~有人帮我们实现~        //抽象方法只有方法名，没有方法的实现        public abstract void doSth();        //1.不能new抽象类，只能靠子类去实现它，仅作为一个约束        //2.抽象方法只能出现在抽象类中，抽象类可以有普通方法        //3.抽象类有构造器，可以派生子类        //4.抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限 用的不多

接口

  • 普通类：只有具体实现

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

  • 接口：只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程~

  • 接口就是规范，定义的是一组规则，"你是什么…必须做什么…"的思想。

  • 接口的本质是约束，就像人间法律一样，制定好大家都遵守。

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

  • 实现类必须要重写接口中的方法

  • 实现类（implements） 可以实现多个接口

//interfacce 定义的关键字，接口都是需要实现类
public interface UserService {


    //接口中所有的关键字都是抽象的，public abstract
    void run(String name);
    void add(String name);
    void delete(String name);
    void query(String name);
}

public interface TimeService  {
    void timer();
}


public class UserServiceImplement implements UserService,TimeService{
    @Override
    public void run(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

  • 内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B就是A的内部类，而A相对B来说就是外部类
    1. 成员内部类：可以操作外部类的私有属性及方法
    2. 静态内部类：static修饰，不能访问外部类私有属性
    3. 局部内部类：外部类的方法里定义的类
    4. 匿名内部类：没有名字初始化类
public class Outer {
    private int id=10;
    public void outer(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        public void getID(){
            System.out.println(id);
        }

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

                }
            }
        }


    }
}

    public static void main(String[] args) {
        Outer outer=new Outer();
        Outer.Inner inner=outer.new Inner();
        inner.getID();
//        outer.outer();

    }

异常

  • 软件程序在运行过程中，经常可能遇到异常问题，异常英文(Exception)，意思是例外，这些例外情况需要我们写程序做出合理的处理，而不至于让程序崩溃。
  • 异常指程序运行中出现的不期而至的各种状况：文件找不到，网络连接错误，非法参数等。
  • 异常发生在程序运行期间，它影响了正常的执行流程。
    在这里插入图片描述

在这里插入图片描述

简单分类

  • 检查型异常：最具代表性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如用户要打开一个不存在的文件时引发的异常，这些异常在编译时不能被简单地忽略。
  • 运行时异常：是可能被程序员避免的异常，与检查性异常相反，运行时异常可以在编译时忽略。
  • 错误Error：错误不是异常，而是脱离程序员控制的问题。错误在代码经常被忽略。例如当栈溢出，一个异常就发生了，它们在编译也检查不到。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

异常处理机制

  • 抛出异常
  • 捕获异常
  • 异常处理关键字：try、catch、finally、throw、throws
  • 注意在异常处理的时候遵循从小到大，throwable包含了error和exception
public static void main(String[] args) {
        int a=1;
        int b=0;


        try{
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("Error");
        }catch(Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }
    }
    public void a(){b();}
    public void b(){a();}
  • throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型
 //如果这方法 ，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws  ArithmeticException{
        if (b==0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
        System.out.println(a/b);
    }

自定义异常

在这里插入图片描述

//自定义的异常类
public class MyExpectation extends Exception {
    private int detail;

    public MyExpectation(int a) {
        this.detail = a;
    }


    //异常的处理信息
    //tostring
    @Override
    public String toString() {
        return "MyExpectation{" +
                "detail=" + detail +
                '}';
    }
}


public class Appcication {
    //可能存在异常方法
    static void test(int a) throws MyExpectation{

        System.out.println("传递的参数为："+a);
        if (a>10){
            throw new MyExpectation(a);//抛出
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {
            test(11);
        }catch (MyExpectation e){
            System.out.println("MyException=>"+e);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IimDp4kZ-1633573131040)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211006162125312.png)]

  • 在自定义一些异常的时候，主要主要继承Exception

部分资源转载于：fllow_wind（大概在输入Scanner输入之前，后面的均是个人手敲）

制作不易：如果本篇文章对你有帮助，不妨点个赞再走！

qq_42186847
关注
  • 7
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7566
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
Java基础知识笔记
qq_40004487的博客
03-12 1355
Java基础笔记参考--狂神说、韩顺平。一定要多敲代码！多敲代码！多敲代码！
2024年最全【狂神说Java】JUC笔记(1)，Java工程师面试该怎么准备
2301_82241675的博客
05-08 845
切莫死记硬背，小心面试官直接让你出门右拐1000道互联网Java面试题：
Java 入门基础（笔记）
lbzdny的博客
02-06 574
java简单介绍，运行环境介绍以及一些基础知识
JAVA学习笔记（1）
猿始森林
04-05 362
观看尚学堂马士兵老师的JAVA课程的笔记 内存分析  局部变量和成员变量  类  面向对象思想  引用 一、内存的四个区域 不同的操作系统每个程序内存分的区域不一样，但主要是四个： 1.代码区：用来存放代码，每次找到代码区的 main()方法开始执行 2.数据区：存放静态变量和字符串常量 2.栈：存放局部变量   3.堆：动态申请内存（所有new出来的东西都在堆里面）   二、局
狂神说Java全栈学习路线
热门推荐
狂神说
03-06 6万+
很多同学学习Java苦于没有自己的完整学习步骤，在这里，秦老师给大家奉上一份完整的学习计划~干货满满，关注收藏转发呀！不胜感激！一、Java基础二、JavaWeb三、SSM框架四、Lin...
狂神说Java-SpringMVC学习笔记
05-17
狂神说Java——SpringMVC学习笔记 内容概要： 1、了解什么是SpringMVC 2、RestFul和控制器 3、转发和重定向 4、数据处理 5、JSON 6、SSM项目整合 7、Ajax 8、拦截器+文件上传下载 能学到什么：详细了解SpringMVC基础...
狂神说Java-Spring学习笔记
最新发布
05-17
狂神说Java——Spring学习笔记 内容概要： 1、了解什么是Spring 2、IOC 3、Spring配置 4、依赖注入 5、Bean的自动装配 6、注解开发 7、代理模式 8、AOP 能学到什么：详细了解Spring基础以及使用 阅读建议： 建议配合...
狂神说Java-Mybatis学习笔记
05-17
狂神说Java——Mybatis学习笔记
狂神说java系列笔记（java基础+javaweb+ssm+微服务）全套
04-26
【标题】：“狂神说java系列笔记”涵盖了Java的基础、Web开发、SSM框架以及微服务等关键领域，是一套全面深入的Java学习资源。它旨在帮助初学者和进阶者掌握Java编程语言的核心概念，以及在实际项目开发中的应用。 ...
网络编程-狂神说Java学习笔记
07-20
"狂神说Java学习笔记"提供了深入理解和实践网络编程的宝贵资源。本笔记主要涵盖了以下几个关键知识点： 1. **Java网络编程基础**：Java通过Socket API提供了网络通信的能力。Socket代表了网络上的两个应用程序之间...
JavaSE回顾总结（狂神说java）.xmind
05-11
javaSE回顾总结，学习笔记，查漏补缺。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等.
狂神说Java Vue笔记
12-02
笔记格式为makerdown格式的.md 笔记包含所有的视频中的内容
java全栈笔记
02-21
全栈练习笔记，用思维导图把各个技术点全部串联起来。
狂神说Java系列笔记.rar
02-10
2020年7月份PDF笔记，从Java基础内容到微服务、分布式相关笔记；
(25)Teach girls bravery, not perfection
weixin_30872499的博客
04-26 2245
https://www.ted.com/talks/reshma_saujani_teach_girls_bravery_not_perfection/transcript00:12So a few years ago, I did something really brave, or some would say really stupid. I ran for Congress. 00:2...
【狂神说Java（零基础）预科班学习笔记】计算机常识汇总
npc家的小朋友的博客
04-28 237
Computer：全称电子计算机，俗称电脑。能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。由硬件和软件组成常见的形式有台式计算机、笔记本计算机、大型计算机等。广泛应用在：科学计算，数据处理，自动控制，计算机辅助设计，人工智能，网络等领域。
【狂神说Java笔记】Java基础
qq_41047516的博客
08-02 525
【狂神说Java笔记】Java基础
狂神说java系列笔记
05-09
狂神说Java系列笔记是一系列由狂神（Java资深讲师）所著的Java学习笔记，包括Java基础、JavaWeb、Spring、SpringBoot、MyBatis等方面的内容。这个系列笔记主要面向Java初学者和希望系统学习Java技术的人群，通过简洁...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值