Java学习笔记

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);
《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源 威信搜索公众号【编程进阶路】
}

}

}

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

}

}

//不用static的话效果不一样。

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

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大，但是不能缩小：public->Protected->Default->private

4.抛出异常：范围，可以缩小，但是不能扩大：ClssNotFoundExpection–>Exception（大）

重写，子类的方法和父类必要一致：方法体不同!

为什么需要重写？

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

2.alt+insert：override；

39.多态。可动态编译：可扩展性。

1.即同一方法可以根据发送对象的不同而采取不同的行为方式。

2.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

多态存在的条件：

有继承关系

子类重写父类方法

父类引用指向子类对象

注意：多态是方法的多态，属性没有多态。

例如：

Student extends Person

Student s1 = new Student(); //子类能调用的方法，是自己的或者父类的，而父类不能直接调用子类的方法。父类调用子类时，会设计强制转换！！！

Person s2 = new Student(); //父类的医用指向子类的类型

Object s3 = new Student(); //多态，相当于一个类，继承了其他类，其就有多种状态。

((Student) s2).方法//s2调用子类方法的时候。当然，要有父子关系！

不能重写的方法：

static 方法，属于类，不属于实例

final 常量

private 方法

40.instanceof和类型转换。

1.instanceof用于判断是否是父子关系。

X instanceof Y来判断，返回true ，false。

2.类型转换

高转低–强转，低转高–不需要。

例如：将Person类型转换为Student类型

Person obj = new Person();

Student student = (Student) obj;

注意：转换，可能会丢失一些自己的方法。

41.static详解。

static方法在程序加载时就已经加载了，创建对象时只执行一次，知道程序结束。而其他变量，方法，每创建一个对象，就执行一次。

静态导入包：import static java.lang.Math.random;

final 不能被继承

42.抽象类。abstract//父债子偿

abstract ，抽象方法，只有方法名字，没有方法的实现。

public abstract void doSomething();

将由它的子类来完成它的方法体书写。

1.不能new这个抽象类，只能靠子类去实现它。：约束。

2.抽象类中可以写普通方法。

3.抽象方法必须写在抽象类中。

43.接口。

普通类：只有具体实现。

抽象类：具体实现和规范（抽闲方法）都有！

接口：只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程

用interface定义。

子类通过implements关键字来实现它，再重写里面的方法。

作用：

1.约束

2.定义一些方法，让不同的人实现

3.public abstract

4.public static final

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

6.implements可以实现多个接口

7.必须要重写接口中的方法

44.内部类。

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

一个java类中可以有多个class类但是只能有一个public class类

1.成员内部类。

例子：

package Extend;

public class Outer {

private int id;

public void out(){

System.out.println(“外部类的方法”);

}

public class Inner{

public void in(){

System.out.println(“这是内部类方法”);

}

//获得外部类的私有属性

public void getId(){

System.out.println(id);

}

}

}

package Extend;

public class Demo {

public static void main(String[] args) {

//new

Outer outer = new Outer();

//通过外部类来实例化内部类

outer.out();

Outer.Inner inner = outer.new Inner();

inner.in();