526互联

JAVA SE 完结

发布时间 2023-09-16 11:36:19作者: Holle小菜狗

JAVA SE

基本的Dos 命令

#盘符切换  
D:
#查看当前目录下的所有文件 
dir
#切换目录(/d 换盘符 写在cd 后) 
cd 文件夹
#返回上一级
cd..
#清理屏幕 
cls
#打开应用 
calc 计算机 ，notepad 记事本，mspaint 画图
#ping 命令 可以获得 IP地址 延迟 一般用来测试网络,是否正常
ping www.baidu.com(网站网址)
#创建文件 
md 目录名
#移除文件 
rd 目录名
#创建文件 
cd> 文件名.后缀
#删除文件 
del 文件名.后缀

java特性和优势

简单性

面向对象

可移植性

高性能

分布式

动态性

多线程

安全性

健壮性

java三大版本

JavaSE 标准版(基础)

JavaME 嵌入式开发(已躺)

JavaEE E企业级开发(web端，服务器开发)

JDK , JRE , JVM

 

Java开发环境搭建

JDK下载与安装

配置环境变量

测试是否成功:cmd—>java -version

HelloWorld 及 简单语法规则

建立一个Hello.java文件

编写代码

public class Hello {
    public static void main(String[] args){
        //idea快捷键 psvm 快速打出输出方法
        System.out.print("Hello World 你好世间");
        //idea快捷键 souf
    }
}

注意单词字母大小问题

文件名和类名要一样，首字母要大写

 

JAVA基础语法

注释

//单行注释
​
/*
多行注释
*/
​
/**
* 文档注释
* @description helloworld
* @author 
*/

标识符

关键字

关键字

关键字不能用作标识符

标识符

所有标识符都应该以字母A-Z，a-z，美元$，或者下划线_开头

标识符世大小写敏感的 大写不等于小写

数据类型

强类型语言:要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用(必须先初始化)

java的数据类型分为基本类型和引用类型：
基本数据类型

数值类型：整数类型(byte，short，int，long)，浮点类型(float，double)，字符类型(char)

boolean类型：占1位其值只有true和false两个

 

        //整数
        int num1 =10;
        byte num2 = 12;
        short num3 = 30;
        long num4 = 40L;//long类型要在数字后面加个l
        // 小数
        float num5 = 50.1F;//float类型要在数字后面加个l，表示有限
        double num6 =3.1415926;
        //字符
        char name ='v';
        //字符串，String 不是关键字，是类
        String namea = "噜啦啦";
        //布尔值 表是非
        boolean flag =true;
        boolean flag1 = false;
引用数据类型：类，接口，数组

类型转换

byte,short,char <int<long<float<double(类型高低)

高到低，强制转换： 高类型 变量名 = （低类型）变量名；

低到高，自动转换：低类型 变量名=变量名；

不能对不相干的类型互相转换；

变量

类变量

实例变量

局部变量

public class Main {
    //类变量 static
    static double salary = 2500;
    // 属性：变量
​
    /*
    实例变量：从属于对象，如果不自行初始化，这个类型的默认值 就是 0，0.0
    布尔值：默认是false
    除了基本类型，其余的默认值都是null
     */
    String name;
    int age;
​
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
       int i = 10;
       System.out.println(i);
​
       //变量类型 变量名字 =new demo08();
        Main main1 =new Main();
        System.out.println(main1.age);
​
        //类变量 static
        System.out.println(salary);
​
​
    }
}

 

常量

初始化后不能在改变值。

常量名一般使用大写字符

//final 常量名 =值;
//final double PI = 3.14;
public class DEMO2 {
    //final 修饰符 不区分前后顺序
    final static double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}
​

运算符

算术运算符

+,-,*,/,%,++,--

赋值运算符

=

关系运算符

<,>,>=,<=,==,!=,instanceof

逻辑运算符

&&与and，都真为真

||或or ，一假为假

！非，取反

 

位运算符

&，|，^，~，>>,<<,>>>

/*
A=0011 1100
B=0000 1101
------------
A&B=0000 1100,有零则零
A|B=0011 1101，有1则1
A^B=0011 0001，相同为0
 ~B=1111 0010，取反
 
 左移 << 相当于*2
 右移 >> 相当于/2
 二进制左右移动
*/

 

条件运算符

? , :

/*
x?y：z
如果x为真 ，则为y ，假为z
*/

 

扩展赋值运算符

+=,-=,*=,/=

/*
a+=b,a=a+b
a-=b,a=a-b
*/

包机制

java帮助文档

javadoc文档

IDEA快捷键 /**回车

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

Scanner 对象

package DAY01;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Demo4 {
    public static void main(String[] args) {
        //创建一个扫描对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接收
            //String str = scanner.next();
            String str = scanner.nextLine();
            System.out.println("输入内容为："+str);

        }
        //凡是属于io流的类如果不关闭就会一直占用资源，所以要养成用完就关掉的习惯
        scanner.close();

    }
}

package DAY01;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Demo4 {
    public static void main(String[] args) {
        //创建一个扫描对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("使用nextLine方式接收请输入：");
        String str = scanner.nextLine();
        
        System.out.println("输入内容为："+str);

        scanner.close();

    }
}

next()：

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

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

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

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

nextLine()：

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

2.可以获得空白。 

package DAY01;

import java.util.Scanner;

public class Demo5 {
    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();
    }
}

顺序结构

按顺序一句一句执行

选择结构

if 单双多嵌套选择结构

if(){
    
}if else{
    
}else{
    
}

switch 多选择结构

switch(){
    case 1：
        //语句
        break;
    case 2:
        //语句
        break;
    case .....
        //语句
        .....
    default:
        //未知的所有选择default
        
        
}

 

循环结构

while 循环: 先判断后执行

while(布尔表达式){
    //循环内容
}

do...while 循环: 先执行后判断，至少执行一次

do{
    //语句
}while(布尔表达式);

for 循环

// for(初始化，布尔表达式，自更新){}
for(i=1;i<5;i++){
    //循环内容
}

for(;;){}//死循环写法

 

扩展:println输出会换行，print不会换行

练习 ，九九乘法表

package DAY01;

import java.sql.SQLOutput;

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

增强for 循环

package DAY01;

public class Demo7 {
    public static void main(String[] args) {
        int[] number = {10,20,30,40,50,60};
        //遍历数组
        for (int x:number){
            System.out.println(x);
        }
    }
}
package DAY01;

public class Demo7 {
    public static void main(String[] args) {
        int[] number = {10,20,30,40,50,60};
        //遍历数组
        for (int x:number){
            System.out.println(x);
        }
    }
}

 

break continue goto

break 终止循环

continue 跳过本次循环，执行下一次

练习打印三角形

package DAY01;

public class Demo8 {
    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {
            for (int j = 5; j > i; j--) {
                System.out.print(" ");
            }
            for (int j = 0; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println("");
        }
    }
}

 

Java方法

package DAY01;

public class Demo9 {
    public static void main(String[] args) {
        int sum = add(2, 3);
        System.out.println(sum);
        int sum2 = add(2, 3,4);
        System.out.println(sum2);
        test();
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static int add(int a,int b,int c){
        return a+b+c;
    }
    public static   void test(){
        System.out.println("测试方法");
    }
    /*
     修饰符 返回值类型 方法名 (参数类型 参数名){
        方法体

    }
    */
}

方法重载

同名称方法，不同返回值或者参数，需要什么返回值或者传递参数，调用时自动选择对应的方法。

命令行传参

用命令行调用，并传参

可变参数

package Day02;

public class Demo1 {
    public static void main(String[] args) {
        sum(1);
        sum(1,2,3);
    }
    public static void  sum(int... i){
        //相当于数组，可以因对多变的传参，这个只能卸载普通参数的最后面
        System.out.println(i[0]);
    }
}

 

递归

方法A，自己调用自己

小计算用递归，大计算尽量不要用递归，会影响性能。

package Day02;

import java.sql.SQLOutput;

public class Demo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        int sum1 = demo2.sum(5);
        //  int sum = sum(3);
        System.out.println(sum1);
        System.out.println(sum(4));
    }

    public static int sum(int i) {
        int sum=1;
        if (i==1){
            return sum;
        }else {
            return i*sum(i-1);
        }

    }
}

练习题 加减乘除计算器

package Day02;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Demo3 {
    public static void main(String[] args) {
        i1();
    }
    public static void i1() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("进行加减乘除，请您输入 数字符号数字 的格式：");
        String i = scanner.next();
        sum(i);
    }
    public static void i2() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("是否继续，输入“1”继续，“2”结束");
        int a = scanner.nextInt();
        if (a==1){
            System.out.println("进行加减乘除，请您输入 数字符号数字 的格式：");
            String i = scanner.next();
            sum(i);
        }else {
            System.out.println("感谢使用");
            return;
        }
    }
    public static void sum(String i2) {
        for (int i=0;i<i2.length();i++){
            int q=i2.length();
            while (i2.charAt(i)=='+' || i2.charAt(i)=='-'|| i2.charAt(i)=='*' || i2.charAt(i)=='/'){
                String su1="";
                String su2="";
                Integer su3=0;
                Integer su4=0;
                double sum=0;
                switch (i2.charAt(i)){
                    case '+' :
                        for (int j=0;j<i;j++){
                            su1+=i2.charAt(j);
                            su3 = Integer.parseInt(su1);
                        }
                        for (int j1=i+1;j1<q;j1++){
                            su2+=i2.charAt(j1);
                            su4 = Integer.parseInt(su2);
                        }
                        sum=(double)su3+(double)su4;
                        System.out.println(su3+"+"+su4+"="+sum);
                        i2();
                        return;
                    case '-' :
                        for (int j=0;j<i;j++){
                            su1+=i2.charAt(j);
                            su3 = Integer.parseInt(su1);
                        }
                        for (int j1=i+1;j1<q;j1++){
                            su2+=i2.charAt(j1);
                            su4 = Integer.parseInt(su2);
                        }
                        sum=(double)su3-(double)su4;
                        System.out.println(su3+"-"+su4+"="+sum);
                        i2();
                        return;
                    case '*' :

                        for (int j=0;j<i;j++){
                            su1+=i2.charAt(j);
                            su3 = Integer.parseInt(su1);
                        }
                        for (int j1=i+1;j1<q;j1++){
                            su2+=i2.charAt(j1);
                            su4 = Integer.parseInt(su2);
                        }
                        sum=(double)su3*(double)su4;
                        System.out.println(su3+"*"+su4+"="+sum);
                        i2();
                        return;
                    case '/' :

                        for (int j=0;j<i;j++){
                            su1+=i2.charAt(j);
                            su3 = Integer.parseInt(su1);
                        }
                        for (int j1=i+1;j1<q;j1++){
                            su2+=i2.charAt(j1);
                            su4 = Integer.parseInt(su2);
                        }
                        sum=(double)su3/(double)su4;
                        System.out.println(su3+"/"+su4+"="+sum);
                        i2();
                        return;
                }
            }
        }
    }
}

 

数组

相同类型数据的有序集合，一旦定义就不可变

//声明，创建，赋值，输出
//变量类型 变量名字=变量的值;
int[] nums=new int[10];
nums[0]=1;
System.out.println(nums[0]);

//静态初始化
int[] a={1,2,3,4,5,6};

二维数组

int[][] arr=new int[2][2];
arr[0][0]=1;
arr[0][1]=2;
System.out.println(arr[0][0]);

int[][] arry={{1,2},{3,4}};
System.out.println(arry[0][1]);

Array 工具类

//Arrays.toString(数组名称);
//打印数组元素

 

冒泡排序

package Day02;

import java.util.Arrays;

public class Demo5 {
    public static void main(String[] args) {
        int[] oo={3,5,4,8,6,2,1,45,65,23,12};
        for (int i = 0; i < oo.length-1; i++) {
            for (int j = i+1; j < oo.length; j++) {
                if (oo[i]>oo[j]) {
                    int o = oo[j];
                    oo[j] = oo[i];
                    oo[i] = o ;
                }
            }
        }
        System.out.println(Arrays.toString(oo));
    }
}

 

稀疏数组

创建一个小数组，记录大数组的空间和数值坐标

 

面向对象

package Day02;

public class Demo6 {
    String name;
    int age;
    public void Studen(){
        System.out.println(name+"学生"+age+"岁");
    }
}

package Day02;

public class Demo7 {
    public static void main(String[] args) {
        Demo6 demo6 = new Demo6();
        demo6.name = "李华";
        demo6.age  = 18;
        System.out.println(demo6.name+demo6.age);
        demo6.Studen();
    }
}

 

构造器

一个类什么都不写也存在一个本身方法、这个方法可以实例化一些对象

使用new关键字，本质是在调用构造器 

package Day02;

import javax.xml.soap.Name;

public class Demo8 {
    String name;
    int age;

    //无参用来初始化
    public Demo8(){
        
    }

    //有参构造，一旦定义有参构造，无参构造必须显式定义(就是把他敲出来)
    public Demo8(String name){
        this.name = name;
    }
    //ait +inste 生成构造器
}

package Day02;

public class Demo7 {
    public static void main(String[] args) {
        Demo8 demo8 = new Demo8("梨花");
        System.out.println(demo8.name);
    }
}

 

封装

private 私有

get / set

package Day02;
​
public class Demo9 {
​
    //快捷生成set,get ait+inster
    /*
    提高程序的安全性，保护数据
    隐藏代码的实现细节
    统一接口
    系统克维护增加了
     */
    private String name;
    private int age;
    private char sex;
    public String getName() {
        return name;
    }
​
    public int getAge() {
        return age;
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public void setAge(int age) {
        if (age<100 && age>0){
            this.age = age;
        }else {
            this.age= 3;
            System.out.println("不正常");
        }
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
​
​
​
​
​
}
​
package Day02;
​
public class Demo10 {
    public static void main(String[] args) {
        Demo9 demo9 = new Demo9();
​
        demo9.setName("李华");
        System.out.println(demo9.getName());
​
        demo9.setAge(550);
        System.out.println(demo9.getAge());
    }
}
​

 

继承 extends

子类继承父类，就会拥有父类的全部方法

只有单继承，没有多继承。多个儿子有一个爸爸

Ctrl+ h 快捷键 查看继承关系

Super 子类使用符类方法或者参数时调用方法

方法的重写，注解 @Override，重写时方法名必须相同，参数列表必须相同，

修饰符范围可以扩大但不可以缩小，修饰符：Public>Protected>Default>Private

抛出的异常，范围可以缩小，不能扩大。ClassNotFoundException --> Exception(大)

package Day03;

public class Demo1 {
    String name = "老大";

    public void ff(){
        System.out.println("一百万");
    }
}

package Day03;
​
public class Demo2 extends Demo1 {
    String name = "小强子";
    public void ff2(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    @Override //注解，写不写都可以，重写
    public void ff(){
        System.out.println("二百万");
    }
​
}
​
package Day03;
​
public class Dmeo3 {
    public static void main(String[] args) {
        //方法的调用只和左边的，定义数据类型有关
        Demo2 demo2 = new Demo2();
        demo2.ff();
        
        demo2.ff2("小花子");
        
        //父类的引用指向了子类
        Demo1 demo1 = new Demo2();
        demo1.ff();
​
    }
}
​

多态

存在的三个必要条件: 继承，重写，父类引用指向子类对象：Parent p = new Child();

 

instanceof 和 类型转换

  • instanceof 是 Java 的保留关键字。

  • 作用是：测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

  • instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

  • 说明下：类的实例包含本身的实例，以及所有直接或间接子类的实例

父类引用指向子类的对象

把子类转换为父类，向上转型

把父类转换为子类，向下转型，强制转换

方便方法的调用，减少重复的代码

static 关键字详解

静态变量，也称类变量，可以通过类名.静态变量直接调用

 

抽象类 abstract

package Day03;
​
//abstract 抽象类：类extends：单继承~ （接口可以多继承）
public abstract class Demo4 {
    //约束~
    //abstract，抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();
    //不能new这个抽象类，只能靠子类去实现它，约束
    //抽象类中可以写普通的方法
    //抽象方法必须在抽象类中
}
​

接口 interface

package Day03;
​
public interface Demo5 {
​
    void add(String name);
    void delete(String name);
    void update(String name);
}
​
package Day03;
//通过类实现接口，重写接口中的方法
//一个类可以继承多个接口用，逗号隔断
public class Demo51 implements Demo5 {
    @Override
    public void add(String name) {
​
    }
​
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
}
​

内部类

异常

package Day03;
​
public class Demo6 {
​
    public static void main(String[] args) {
        int a = 1;
        int b =0;
        try{
            System.out.println(a/b);
            //正常执行的化就会出现异常
        }catch(Error e){//catch 想要捕获的异常类型
            System.out.println("Error");
        }catch(Exception e){//catch 想要捕获的异常类型
            System.out.println("Exception");
        }catch(Throwable t){//catch 想要捕获的异常类型
            System.out.println("Throwable");
        }finally {//处理善后工作
            System.out.println("finally");
        }
​
    }
}
​