Java学习笔记

break;

default:

//若干语句;

}

9.循环语句。//类似C

9.1for循环语句。//最简单的循环语句。

for(表达式1;表达式2;表达式3){

若干语句;

}

9.2while循环语句。

while(表达式){

若干语句;

}

9.3do-while循环语句。

do{

若干语句;

}while(表达式);

10.break、continue、goto语句。

break;语句可以用于跳出循环；

continue;语句可以用于跳出本次循环，进入下一次循环中。

goto;语句用于跳转，但减少使用，容易出问题。

11.变量。

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

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

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

注意：

每个变量都有类型，类型可以是基本类型，也可以是引用类型。

变量名必须是合法的标识符。

变量声明是一条完整的语句，因此每一个生命都必须以分号结尾。

变量作用域：

类变量、实例变量、局部变量。

public class Demo3 {

//类变量

static double salary = 2500;

//属性：变量

//实例变量，从属于对象；如果不初始化，就会变成默认值，0，0.0，boolean值默认false；

//除了基本类型，其余的默认值都是null；

String name;

int age;

//main方法

public static void main(String[] args) {

int a=1;//局部变量，必须声明和初始化值。

System.out.println(a);

//变量类型 变量名字=new Demo3();

Demo3 demo3=new Demo3();

System.out.println(demo3.age);

System.out.println(demo3.name);

//类变量

System.out.println(salary);

}

}

12.常量（Constant）。

final //修饰符，不存在先后。

static final int a = 2;

final static int a = 2;

13.命名规范。

14.字符串拼接问题。

int a=10;

int b=20;

System.out.println(a+b);//30

System.out.println(“”+a+b);//1020

System.out.println(a+b+“”);//30

15.包机制。//本质文件夹

16.JavaDoc。//Jdk帮助文档

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

cmd的javadoc命令！！！

17.Scanner类

next():

1.一定要读取到有效字符后才可以结束输入。

2.对输入有效字符之前遇到空白，next()方法会自动将其去掉。

3.只要输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4.next()不能得到带有空格的字符串。

nextLine():

1.以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。

2.可以获得空白。

例子：

package Scanner;

import java.util.Scanner;

public class Demo01 {

public static void main(String[] args) {

//创建一个扫描对象，用于接收键盘数据

Scanner scanner = new Scanner(System.in);

System.out.println(“使用next方法接受数据：”);

//判断用户有没有输入字符串

if (scanner.hasNext()){

String str = scanner.next();

System.out.println(“输出的字符为：”+str);

}

//凡是IO流的类如果不关闭会一直占用资源，要养成好习惯就关掉。

scanner.close();

}

}

package Scanner;

import java.util.Scanner;

public class Demo02 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println(“使用nextLine方法接受：”);

if (scanner.hasNextLine()){

String str = scanner.nextLine();

System.out.println(“输出的内容为：”+str);

}

scanner.close();

}

}

18.顺序结构。

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

顺序结构是最简单的算法结构。

语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

19.增强for循环。//重点是用来循环数组和循环的。

例子：

int[] num = {10,20,30,40,50};

for (int x:num){

System.out.println(x);

}

20.Java方法详解。

System.out.println

类 对象 方法

例子：

package Method;

public class Demo01 {

//main方法

public static void main(String[] args) {

int sum = add(1,2);

System.out.println(sum);

}

//加法

public static int add(int a,int b){//static 类方法

return a+b;

}

}

21.方法的重载。\一个方法名字可以相同，但参数列表（个数、类型、参数）不能相同。

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

例子：

package Method;

public class Demo02 {

public static void main(String[] args) {

int large = max(10,20);

System.out.println(large);

}

//比大小

public static double max(double num1,double num2){

double result = 0;

if (num1>num2){

result = num1;

}else{

result = num2;

}

return result;

}

public static int max(int num1,int num2){

int result = 0;

if (num1>num2){

result = num1;

}else{

result = num2;

}

return result;

}

}

22.命令行传参。

。。。。。

23.可变参数。

参数不定向

*在方法声明中。在指向参数类型后加一个省略号(…)。

例子：

package Method;

public class Demo04 {

public static void main(String[] args) {

Demo04 demo04 = new Demo04();

demo04.method(1,2,3,4,5);

}

public void method(int x ,int… i){

System.out.println(x);

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

System.out.println(i[1]);

System.out.println(i[2]);

System.out.println(i[3]);

}

}

24.递归。\自己调用自己。\数过大的时候就有麻烦了，只能调用较小的数。

递归头：什么时候调用自身方法，如果没有头，将陷入死循环。

递归体：什么时候需要调用自身方法。

例子：package Method;

public class Demo05 {

public static void main(String[] args) {

System.out.println(test(5));

}

public static int test(int n){

if (n==1){

return 1;

}else{

return n*test(n-1);

}

}

}

25.数组。

25.1.数组是相同类型数据的有序集合。

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。

其中，每一个数据称作为一个数组元素，每个数组元素可以通过一个下标来访问它们。

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

int[] nums;//定义1

int nums2[];//定义2

二维数组也是如此。

注意：1.Java不允许在声明数组中的方括号内指定数组元素的个数。

2.构成二维数组的一维数组不必有相同的长度，在创建二维数组的时候可以分别指定构成该二维数组的一维数组的长度。

如下：

int a[][] = new int[3][];

a[0] = new int[6];

a[1] = new int[12];

a[2] = new int[3];

3.和C语言不同的是，Java允许使用int型变量的值指定数组的元素个数；

例如：

int size = 30;

double num[] = new double[size];

package Array;

public class Demo01 {

public static void main(String[] args) {

int[] nums;//定义1

nums = new int[10];

nums[0] = 1;

nums[1] = 1;

nums[2] = 1;

nums[3] = 1;

nums[4] = 1;

nums[5] = 1;

nums[6] = 1;

nums[7] = 1;

nums[8] = 1;

nums[9] = 1;

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

System.out.println(nums[i]);

}

}

}

25.2.length的使用。

数组元素的个数称为数组的长度。

对于一维数组“数组名.length”的值是数组中元素的个数；而，对于二维数组而言“数组名.length”的值是它含有的一维数组的个数。

float a[] = new float[12];

int b[][] = new int[3][4];

a.length = 12;b.length = 3;

25.3初始化。

float boy[] = {21.3f,23.3f,2.2f,45.4f,55.5f}相当于float boy[] = new float[5];然后再逐一赋值。

25.4数组的引用。

数组属于引用类型，因此两个相同类型的数组如果具有相同的引用，它们就必须具有相同的元素。

int a[] = {1,2,3};

int b[] = {4,5};

a = b;

那么数组a中的元素将变成b中的元素，和b[]一模一样。

25.5数组的遍历。

循环遍历

toString()方法遍历。

package Demo;

import java.util.Arrays;

public class Demo09 {

public static void main(String[] args) {

char a[] = {‘a’,‘b’,‘c’,‘d’};

for (int n=0;n<a.length;n++){

System.out.print(a[n]+" ");

}

System.out.println();

for (char ch:a){

System.out.print(ch);

}

System.out.println();

System.out.println(Arrays.toString(a));

}

}

26.jdk帮助文档。

27.冒泡算法。

package Array;

import java.util.Arrays;

public class Demo03 {

public static void main(String[] args) {

//冒泡排序

int[] a = {12,34,1,35,33,734,223,45,251,11};

int[] b = sort(a);

System.out.println(Arrays.toString(b));

}

public static int[] sort(int[] array){

//外层循环，判断我们这个要走多少次

int temp = 0;

for (int i = 0;i<array.length-1;i++){

for (int j = 0;j<array.length-1-i;j++){

if (array[j+1]<array[j]){

temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

}

}

}

return array;

}

}

28.稀疏数组。

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是：

记录数组一共有几行几列，有多少个不同值。

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

例子：

package Array;

public class Demo04 {

public static void main(String[] args) {

//1.创建一个二维数组。2.0：没有棋子，1：黑棋，2：白棋

int[][] array1 = new int[11][11];

array1[1][2] = 1;

array1[2][3] = 2;

//输出原始数组。

System.out.println(“输出原始数组”);

for (int[] ints:array1){

for (int anInt : ints) {

System.out.print(anInt+“\t”);

}

System.out.println();

}

//转换为稀疏数组保存

//获取有效值的个数

int sum = 0;

for (int i = 0; i < 11; i++) {

for (int j = 0; j < 11; j++) {

if (array1[i][j]!=0){

sum++;

}

}

}

System.out.println(“有效值的个数：”+sum);

//创建稀疏数组

int[][] array2 = new int[sum+1][3];

array2[0][0] = 11;

array2[0][1] = 11;

array2[0][2] = sum;

//遍历二维数组，将非零的值，存放在稀疏数组中

int count = 0;

for (int i = 0; i < array1.length; i++) {

for (int j = 0; j < array1[i].length; j++) {

if (array1[i][j]!=0){

count++;

array2[count][0] = i;

array2[count][1] = j;

array2[count][2] = array1[i][j];

}

}

}

//输出

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”);

}

//还原

int[][] array3 = new int[array2[0][0]][array2[0][1]];//11,11

for (int i = 1; i < array2.length; i++) {//从1开始，因为0存了数据

array3[array2[i][0]][array2[i][1]] = array2[i][2];//获取array2中存的行列数及所对应的数据！！！

}

System.out.println(“还原后”);

for (int[] ints:array3){

for (int anInt : ints) {

System.out.print(anInt+“\t”);

}

System.out.println();

}

}

}

29.面向对象。

面向对象过程，步骤的细分。

面向对象编程的本质就是：以类的组织代码，以对象的组织（封装）数据。

三大特性：

封装

继承

多态

从认识论角度考虑是先有对象后有类。对象：具体的事物。类：是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板。

30.方法。

静态方法 static//可以在main函数里面直接调用。

非静态方法//必须要实例化这个类。就是new一下。

例子：//非静态//求输入字符串的每种字母的个数。

package Demo;

import java.util.Locale;

import java.util.Scanner;

public class Demo14 {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

String str = in.nextLine().toLowerCase(Locale.ROOT);//全部准换为小写，便于判断，也可以转换为大写。大写后下面就需要改变。

char[] ch = new char[str.length()];

for (int i = 0; i < ch.length; i++) {

ch[i] = str.charAt(i);

}

new Demo14().chars(ch);

in.close();

}

public void chars(char[] ch){

int[] count = new int[26];//定义26个数组，分别对应a-z，用来统计不同字母的个数。

for (char j = 97; j <= 122; j++) {//a-z 的过程。

for (int i = 0; i < ch.length; i++) {

if (ch[i]==j){

count[j-97]++;//对应字母的个数加一，只能是0-25。要和j相关。25-（122-j）=j-97

}

}

}

for (int i = 0; i < 26; i++) {

if (count[i]!=0){

System.out.println(“(”+(char)(65+i)+“)Num=”+count[i]);

}

}

}

}

//静态

package Demo;

import java.util.Locale;

import java.util.Scanner;

public class Demo14 {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

String str = in.nextLine().toLowerCase(Locale.ROOT);//全部准换为小写，便于判断，也可以转换为大写。大写后下面就需要改变。

char[] ch = new char[str.length()];

for (int i = 0; i < ch.length; i++) {

ch[i] = str.charAt(i);

}

chars(ch);

in.close();

}

public static void chars(char[] ch){

int[] count = new int[26];//定义26个数组，分别对应a-z，用来统计不同字母的个数。

for (char j = 97; j <= 122; j++) {//a-z 的过程。

for (int i = 0; i < ch.length; i++) {

if (ch[i]==j){

count[j-97]++;//对应字母的个数加一，只能是0-25。要和j相关。25-（122-j）=j-97

}

}

}

for (int i = 0; i < 26; i++) {

if (count[i]!=0){

System.out.println(“(”+(char)(65+i)+“)Num=”+count[i]);

}

}

}

}

31.引用传递和值传递。

例子：

package Demo;

//引用传递，对象，本质还是值传递

public class Demo15 {

public static void main(String[] args) {

Person person = new Person();

System.out.println(person.name);

Demo15.change(person);

System.out.println(person.name);

}

public static void change(Person person){

//person是一个对象：指向的是Person person = new Person();这是一个具体的人，可以改变。

person.name = “文璐”;//属性

}

}

//定义了一个Person类，有一个属性。

class Person{

String name;

}

package Demo;

//引用传递，对象，本质还是值传递

public class Demo15 {

public static void main(String[] args) {

// Person person = new Person();

int a=1;

System.out.println(a);

Demo15.change(a);

System.out.println(a);

}

public static void change(int a){

a = 10;

}

}

32.类与对象的关系。

类：抽象的数据类型，它是对某一类事物整体描述/定义，但是并不代表某一个具体的事物。

对象：是抽象概念的具体实例。

new关键字创建对象。

一个项目只有一个main方法！！

33.this的用法

例子：

package Method;

public class Demo06 {

public static void main(String[] args) {

Demo06 de = new Demo06();//创建Demo6的对象。

de.name = “文璐”;//对de里面的name进行赋值

de.study();//de调用study方法。

}

String name;

int age;

public void study(){

System.out.println(this.name+“在学习”);//this指的是本类中的。

}

}

34.构造器

构造器：1.和类名相同。

2.没有返回值。

作用 ：1.new 本质是在调用构造器。

2.初始化对象的值

注意点：1.定义有参构造后，如果想使用无参构造，必须显示的定义一个无参构造。//无参构造不写的话是默认存在的。

IDEA Alt+ins自动生成构造器。

package Application;

public class Application {

public static void main(String[] args) {

Person person = new Person(“wenlu”);

System.out.println(person.name);

}

}

package Application;

public class Person {

//一个类即使什么都不写，也会存在一个方法。默认的

String name;

//实例初始化值

public Person(){//无参构造器

this.name = “文璐”;

}

public Person(String name){//有参构造器，一旦定义了有参构造，无参构造就必须显示定义

this.name = name;

}

}

实验结果会根据Person中是否有参数，调用不同的方法，得到不同的结果！！

35.封装

该露的露，该藏得藏。

我们程序设计要求“高内聚，低耦合”。高内聚就是类类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

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

记住：属性私有，get/set

package Application;

public class Student {

//私有属性

//名字

private String name;

//学号

private int id;

//性别

private char sex;

//get set

public String getName(){

return this.name;

}

public void setName(String name){

this.name = name;

}

}

私有可以用于判断程序是否合理！！，有的赋值是不合法的，封装后，有的数据不用更变

1.提高程序的安全性，保护数据。

2.隐藏代码的实现细节。

3.统一接口。

4.系统可维护性增加了。

36.继承。

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

extends的意思是“扩展”。子类是父类的扩展。

Java中只有单继承没有多继承。

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

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

子类和父类之间，从意义上来讲应该具有“is a”的关系。

//子类继承了父类就可以继承父类的所有方法。

private不能调用。

可以使用get、set方法来调用private。

object类//在Java中所用的类都默认直接或间接继承object类。

37.super//用于访问父类的元素或方法。

注意点：

1.super调用父类的构造方法，必须在构造方法的第一个。

2.super 必须只能出现在子类的方法或者构造方法中！

3.super和this不能同时调用构造方法！

VS this：

1.代表的对象不同：

this：本身调用这个对象

super：代表父类的这个对象。

2.前提：

this：没有继承也可以用

super：只能在继承条件才能使用

3.构造方法：

this()：本类的构造

super()：父类的构造！

38.方法重写–>多态

package Extend;

public class Demo {

public static void main(String[] args) {

A a = new A();

a.test();//A

//父类的引用指向了子类

B b = new A();

b.test();//B

}

}

package Extend;

public class A extends B{

public static void test(){

System.out.println(“A->test()”);

}

}

package Extend;

public class B {

public static void test(){

System.out.println(“B->test()”);

}

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
vate。

object类//在Java中所用的类都默认直接或间接继承object类。

37.super//用于访问父类的元素或方法。

注意点：

1.super调用父类的构造方法，必须在构造方法的第一个。

2.super 必须只能出现在子类的方法或者构造方法中！

3.super和this不能同时调用构造方法！

VS this：

1.代表的对象不同：

this：本身调用这个对象

super：代表父类的这个对象。

2.前提：

this：没有继承也可以用

super：只能在继承条件才能使用

3.构造方法：

this()：本类的构造

super()：父类的构造！

38.方法重写–>多态

package Extend;

public class Demo {

public static void main(String[] args) {

A a = new A();

a.test();//A

//父类的引用指向了子类

B b = new A();

b.test();//B

}

}

package Extend;

public class A extends B{

public static void test(){

System.out.println(“A->test()”);

}

}

package Extend;

public class B {

public static void test(){

System.out.println(“B->test()”);

}

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-yfVssdOA-1715731639393)]

[外链图片转存中…(img-gUDKDD9Y-1715731639394)]

[外链图片转存中…(img-SQYXjyz0-1715731639394)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！