JAVA学习

那我懂你的意思啦

已于 2023-07-25 17:54:06 修改

阅读量560

点赞数 3

文章标签：学习

于 2022-06-21 18:41:27 首次发布

本文链接：https://blog.csdn.net/m0_61894608/article/details/125391404

版权

一、JAVA入门

（1）hello world详解

1.文件后缀名为.java

2.编写代码

public class Hello{
	public static void main(String [] args){
		System.out.print("Hello,World!");
	}
}

3.编译javac java文件,生成class文件

4.运行class文件,java class文件

注意：文件名和类名必须保持一致，并且首字母大写

（2）程序运行机制

1.编译型

2.解释型

（3)IDEA开发

1.快捷语句

psvm=public static void main(String[] args) {}

sout=System.out.println("");

二、JAVA基础

（1）注释

1.单行注释 / /

2.多行注释

3.文档注释

/**

（2）标识符和关键字

1.关键字

2.标识符

1.所有标识符都应该以字母，美元符（$），下划线（-）开始

2.首字母后可以是字母，美元符（$），下划线（-），数字

3.标识符大小写敏感

（3）数据类型

强类型语言：所有变量必须定义后才能使用

小数：浮点数

float类型要在数字后面加F,long类型要在数字后面加L

String不是关键字，是一个类，字符串

char字符

boolean布尔值

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

最好完全避免使用浮点数进行比较

银行业务怎么表示？钱 BigDecimal 数学工具类

所有的字符本质还是数字，可用int将char字符强制转换为数字

转义字符 \t制表符 \n换行....

（4）类型转换

从低到高：byte,short,char<int<long<float<double

强制类型转换（类型）变量名从高到低

自动类型转换从低到高

注意：不能对布尔值进行转换

（5）变量

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

1.作用域

1.类变量在类里，static（修饰符，不存在先后顺序）数据类型

2.实例变量在类里，无static（从属于对象，如果不自行初始化，这个类型的默认值为0 ，0.0，布尔值为false，除了基本类型其他的默认值都是null ）

package operator;

public class Demo02 {
    //实例变量：从属于对象
    String name;
    int age;
//main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);
        Demo02 demo02=new Demo02();//变量类型 变量名字=new Demo02();
        System.out.println(demo02.age);
    }
}

3.局部变量在方法里（必须声明和初始化值）

2.变量的命名规范

类成员变量：首字母小写和驼峰原则 lastName 除了第一个单词以外，后面的单词首字母大写

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线 MAX-VALUE

类名:首字母大写和驼峰原则 GoodMan

方法名：首字母小写和驼峰原则：runRun()

（6）常量

final 常量名=值;

常量名一般使用大写字符

（7）运算符

位运算符：^：相同为0，不同为1

<<左移 >>右移位运算（二进制）

字符串连接符 “ ”+a+b string类型

(在字符串前后加有区别）

（8）包机制

一般利用公司域名倒置作为包名（com.baidu.www)

创建包

导入包（为了使用某一个包的成员）

import com.kuang.base.* (通配符，导入这个包下所有的类）

（9）JavaDoc生成文档

参数信息：

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

三、Java流程控制

（1）用户交互Scanner

基本语法:

Scanner s=new Scanner(System.in);

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

next（）：

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

2.对有效字符前遇到的空白，next（）方法将其自动去掉

3.next（）不能得到带有空格的字符串

nextLine（）：

1.返回的是输入回车之前的所有字符

2.可以获得空白

package Scanner;

import java.util.Scanner;//new Scanner()之后点一下提示第一个

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//输完等号后面的，alt+回车 提示快捷键
        System.out.println("使用next方式接收：");
       //判断用户有没有用输入字符串
        if(scanner.hasNext()){
            String str=scanner.next();
            System.out.println("输出的内容为："+str);
        }
scanner.close();//凡是属于IO流的类如果不关闭会一直占用资源，要用完就关掉
    }
}

(2)Scanner的进阶使用

判断是否为小数或整数并输出

package Scanner;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int i=0;
        float f=0.0F;
        System.out.println("请输入整数：");
        if(scanner.hasNextInt()) {
            i=scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else {
            System.out.println("输入的不是整形数据！");
            System.out.println("请输入小数：");
            if(scanner.hasNextFloat())
            {
                f=scanner.nextFloat();
                System.out.println("小数数据："+f);
            }
            else {
                System.out.println("输入的不是小数数据！");
            }
        }
        scanner.close();
    }
}

输入多个数字，计算其总和与平均数

package Scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double sum = 0;//和
        int m = 0;//计算了多少个数字
        while (scanner.hasNextDouble()) {
            double x =scanner.nextDouble();
            m=m+1;
            sum=sum+x;
        }
        System.out.println(m+"个数的和为"+sum);
        System.out.println(m+"个数的平均值是"+(sum/m));//+号是用来拼接中间字符串的
        scanner.close();
    }

}

（3）顺序结构

是任何一个算法都离不开的一种基本算法结构

（4）选择结构

1.if选择结构

if(布尔表达式）{}

else{}  if(){}

else{}  if(){}

else

equals判断字符串是否相等

一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行

2.switch多选择结构

switch(){
case 1:     break;
default:
}

jdk7后支持字符串String类型 csae"哈哈"

（5）循环结构

1.while循环

while（布尔表达式）
{  }

2.do...while循环

do{
}while(布尔表达式）;

3.for循环

for(初始化；布尔表达式；更新）{
}

4.增强for循环（重点用于数组）

格式：1.声明：变量类型必须与数组类型相匹配

2.表达式：要访问的数组名

for(声明语句：表达式）
{}

package ShunXu;

public class forZengQiang {
    public static void main(String[] args) {
        int []numbers={10,20,30,40,50};
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

5.打印九九乘法表

package struct;

public class ForDemo04 {
    public static void main(String[] args) {
        for (int i = 1; i <=9; i++) {
            for(int j=1;j<=i;j++)
            {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

6.打印三角形

package struct;

public class TestDemo {
    public static void main(String[] args) {
//打印三角形5行
        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();
        }
    }
}

四、Java方法

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){
        return a+b;
    }
}

重载：在一个类中，有相同的函数名称，但形参不同的函数（个数、类型、参数排列顺序不同）

（1）命令行传参

package method;

public class Demo03 {
    public static void main(String[] args) {
        //args.length  数组长度
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

（2）可变参数

1.在方法声明中，在指定参数类型后加一个省略号（...）

2.一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明

package method;

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(1,1,2,3,4,5,6);
    }
    public void test(int x,int...i){//可变参数必须放在最后面
        System.out.println(i[0]);//可以直接当成数组搞
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }

}

（3）用可变参数比较大小

package method;

public class Demo05 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(1,2,3,45,6);
        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 = 0; i < numbers.length; i++) {
            if (numbers[i]>result)
            {
                result=numbers[i];
            }
        }
        System.out.println("Max is"+result);
    }
}

(4)递归

递归：方法自己调用自己

递归结构包括两个部分：递归头：社什么时候不调用自身方法，如果没有头，将陷入死循环

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

1.递归实现阶乘

package method;

public class Demo06 {
    public static void main(String[] args) {
        System.out.println(f(3));
    }
    public static int f(int n){
        if(n==1){
            return 1;
        }
        else{
            return n*f(n-1);
        }
    }
}

五、Java数组

(1)数组的创建与声明

package array;

public class ArrayDemo01 {
    //变量的类型    变量的名字   =  变量的值
    public static void main(String[] args) {
        int[] nums;//声明一个数组
        nums=new int[10];//创建一个数组
        //int []nums=new int[10];    结合表达方式
        nums[0]=1;
        nums[1]=2;
        nums[2]=1;
        nums[3]=2;
        nums[4]=1;
        nums[5]=2;
        nums[6]=1;
        nums[7]=2;
        nums[8]=1;
        nums[9]=2;

        //计算所有元素的和
        int sum=0;
        //获取数组长度：arrays.length
        for (int i = 0; i < nums.length; i++) {
            sum+=i;
        }
        System.out.println(sum);
    }
}

(2)三种初始化

int []a,sout(a)输出的是数组a的引用 sout[a(0)]才是数组元素

char a[],sout(a)输出的是a的全部元素的值

package array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化
        int []a={1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
        //动态初始化
        int[] b=new int [10];
        b[0]=10;
        System.out.println(b[0]);
    }
}

（3）数组的使用

package array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[]arrays={1,2,3,4,5};

    }
    //反转数组
    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;
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+"");
        }
    }
}

（4）二维数组

package array;

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][]array={{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
        
    }
}

（5）Arrays类

package array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int []a={1,6,894,9594,659,168489};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//数组重新排序,升序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);//数组填充
        System.out.println(Arrays.toString(a));
    }
}

(6)稀疏数组

package array;

public class ArrayDemo07 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11   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();
        }
        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);
        //2.创建一个稀疏数组的数组
        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");
        }
        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++) {
            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();
        }
    }
}

六、面向对象

(1)回顾方法的调用

static静态方法调用

非静态方法调用

Java只有值传递

(2)构造器

构造器：

1.和类名相同

2.没有返回值

作用:

1.new本质在调用构造方法

2.初始化对象的值

注意点：定义有参构造之后，如果想使用无参构造，必须显示定义一个无参的构造

（3）封装性

属性私有，get/set

kage oop.demo04;

public class Student {
    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //get  获得这个数据
    public String getName(){
        return this.name;
    }
    //set  给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
    //alt+insert     按住ctrl选择

    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;
    }

    public int getAge() {
        return age;
    }

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

package oop;

import oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("lb");
        System.out.println(s1.getName());
    }
}

(4)继承性

子类（派生类）继承父类（基类），关键字extends

ctrl+h 查看继承关系

在Java中，所有类，都默认直接或间接继承Object类

直接只能继承一个，但可间接的继承多个

1.super

调用父类的构造器，必须要在子类构造器的第一行

super注意点：

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

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

3.super和this不能同时调用构造方法（因为都必须在第一行）

this：本身调用者这个对象 this(): 本类的构造器

super:代表父类对象的应用 super(): 父类的构造器

2.方法重写

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

1方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大但不能缩小 public>protected>private

4.抛出的异样：范围可以被缩小但不能扩大

alt+Insert:override 重写

(3)多态性

同一方法可以根据发送对象的不同而采用多种不同的行为方式

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

2.父类和子类：有练习类型转换异常（ClassCastException）

3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1=new son():

4.如果方法为static(属于类，不属于实例)，final(常量）,private，则无法重写，因此没有多态

1.instanceof和类型转换

X instanceof Y true/false

父转子需强制转换，子转父可直接转但可以能会丢失自己本来的一些方法

父转子

子转父

2.抽象类

抽象类的所有方法，继承它的子类，都必须去实现它的方法，除非子类仍是抽象类

类是单继承的，接口可以多继承

package oop.demo08;

//abstract 抽象类：类 extends  单继承
public abstract class Action {
    //抽象方法，只有方法的名字，没有方法的实现
    public abstract void doSomething();
    //不能new这个抽象类，只能靠子类去实现它
    //抽象类中可以写普通的方法
    //抽象方法必须在抽象类中
    //存在的意义  提高开发效率
}

（4）接口

作用:1.约束

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

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

4.implements可以实现多个接口

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

6.public abstract(函数前面的修饰词)

7.public static final定义常量

package oop.demo09;
//类可以实现接口   implements 接口
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void run(String name) {

    }

    @Override
    public void timer() {

    }
}

package oop.demo09;

//interface 定义的关键字  接口都需要实现类
public interface UserService {
    //接口中所有的定义都是抽象的public abstract(写不写都行)
    void run(String name);
}

package oop.demo09;

public interface TimeService {
    void timer();
}

(5)内部类

A类中再定义一个B类

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

package oop;

import oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();

    }
}

package oop.demo10;

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

七、异常

package exception;

public class Demo01 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //假设要捕获多个异常：从小到大    Error<Exception<Throwable
        try {//try监控区域
            if (b==0){
                throw new ArithmeticException();  //主动的抛出异常
            }
            System.out.println(a/b);
        }catch (ArithmeticException e){//想要捕获的异常类型
            System.out.println("程序出现异常，变量b不能为");
        }finally {//出不出异常都会执行,一般用来关闭程序
            System.out.println("finally");
        }

    }
}

package exception;

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //ctrl+alt+t   可直接调用包裹的函数
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            throw new RuntimeException(e);//打印错误的栈信息
        } finally {
        }

    }
}

package exception;

public class Test1 {
    public static void main(String[] args) {
        try {
            new Test1().test(1,0);
        } catch (ArithmeticException e) {
            throw new RuntimeException(e);
        }
    }
    //假设这方法中，处理不了这个异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();//主动的抛出异常，一般在方法中使用
        }
    }
}