Javase入门下

最新推荐文章于 2024-05-28 09:25:21 发布

fishsun1126

最新推荐文章于 2024-05-28 09:25:21 发布

阅读量104

点赞数

分类专栏： JAVASE基础文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/fishsun1126/article/details/125502774

版权

JAVASE基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java入门下

Scanner对象

我们可以通过Scanner类来获取用户的输入
基本语法：
Scanner s = new Scanner (System.in);
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前需要使用hasNext()与hasNextLine()判断是否还有输入的数据.:
注意: 同输入Hello word，next为Hello，nextline为Hello word

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()){
            //使用next方式接收
            String str= scanner.next();//程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }
        scanner.close();//属于IO流的类 如果不关闭会一直占用资源
    }
}

next():
1.一定要读取到有效字符后才可以输入
2.对输入有效字符前的空格，next()方法会自动将其去掉
3.只有输入有效字符后才能将其后面输入的空格作为分隔符或者结束符，假设输入hello world，结果只会显示hello
4.next()不能得到带有空格的字符串
nextLine()：
1.以回车为结束符，结果会显示输入回车之前的所有字符
2.可以获得空白

Scanner对象总结：

next与nextline有区别
要加上import java.util.Scanner;在上面
最后输入scanner.close();以节省占用内存

顺序结构（从上到下依次进行）是基本算法结构

package struct;

public class ShunXuDemo {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

选择结构

if单选择结构

语法：

if(布尔表达式){//如果布尔表达式为true将执行的语句}

package struct;
 
import java.util.Scanner;
 
public class Ifdemo01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入一个内容：");
        String s=scanner.nextLine();
        //equals:判断字符串是否相等
        if(s.equals("hello")){
            System.out.println(s);
        }else{
            System.out.println("error");
        }
        scanner.close();
    }
}

if双选择结构

语法：
if(布尔表达式){
//如果布尔表达式的值为true
}
else{
//如果布尔表达式的值为false
}

package struct;

import java.util.Scanner;

public class IfDemo2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();
        if(score>60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();
    }
}

if多选择结构

语法：
if(布尔表达式 1){
//如果布尔表达式1的值为true执行代码
}else if(布尔表达式 2){
同上
}else if(布尔表达式 3){
}else {
//如果以上布尔表达式都不为true执行代码
}

package struct;
 
import java.util.Scanner;
 
public class IfDemo3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("input grade:");
        int grade = scanner.nextInt();
        if(50<grade&&grade<60){
            System.out.println("C");
        }else if(grade>=60&&grade<80){
            System.out.println("B");
        } else if (grade>80&&grade<=100) {
            System.out.println("A");
        }else {
            System.out.println("D");
        }
        scanner.close();
    }
}

嵌套结构类推

switch多选择结构

switch(expression){
case value:
//语句
break;//可选
case value:
//语句
break;//可选
//你可以有任意数量的case语句
default：//可选
//语句
}

package struct;


public class switchDemo01 {
    public static void main(String[] args) {
        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;
            case 'E':
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
        }

    }
}

switch变量类型：
byte、short 、int 、char
string类型
case标签必须为字符常量或字面量

循环结构

while循环

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

只要布尔表达式为true，就会一直执行下去
需要一个表达式失效的方式来结束循环

package struct;
 
public class whiledemo01 {
    public static void main(String[] args) {
        //输出1~100
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);//若这个语句不在循环里 则显示的结果为 100，而不是1~100
        }
    }
}

package struct;
 
public class whiledemo03 {
    public static void main(String[] args) {
        //计算1+2+...+100的和
        int i=0;
        int sum=0;
        while(i<=100){
            i++;
            sum+=i;
            System.out.println(i);
        }
        System.out.println(sum);
    }
}

do…while循环

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

注意点

do…while是先执行后判断！
while先判断后执行
只要布尔表达式为true，循环就会一直执行下去

package struct;
 
public class dowhile {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        do{
            i++;
            sum+=i;
            System.out.println(i);
 
        }while (i<=100);
    }
}

for循环

for(初始化；布尔表达式；更新){
//代码语句
}

package struct;
 
public class fordemo02 {
    public static void main(String[] args) {
        //0~100之间偶数和奇数的和
        int sum1=0;
        int sum2=0;
        for(int i1=0;i1<=100;i1+=2){
            sum1+=i1;
            System.out.println(i1);
        }
        System.out.println("结束偶数循环");
        for(int i2=1;i2<=99;i2+=2){
            sum2+=i2;
            System.out.println(i2);
        }
        System.out.println("结束奇数循环");
        System.out.println(sum1);//偶数 2550
        System.out.println(sum2);//奇数 2500
    }
}

package struct;
 
public class fordemo03 {
    public static void main(String[] args) {
        //用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        for(int i=1;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){//每行第三个数能被15整除 1个数是5倍 3个数15倍
                 System.out.println();
            }
        }
        //println 输出完会换行
        //print 输出完不会换行
    }
}

package struct;
//九九乘法表 先打印第一列 然后将固定的1用一个循环包起来 最后去掉重复项样式
public class fordemo04 {
    public static void main(String[] args) {
        for (int j = 1; j <= 9; j++) {
 
 
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" + (j* i)+"\t");
            }
            System.out.println();
        }
    }
}

数组的增强型for循环

for(声明语句：表达式)

{
//代码句子
}
声明语句：声明新的局部变量，该变量类型必须和数组元素的类型相匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
表达式：表达式时要访问的数组名，或者是返回值数组的方法

package struct;
 
public class fordemo05 {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50};//定义了一个数组
        for(int i=0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("=============");
        //遍历数组元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

break continue goto关键字

break:在任何循环语句的主体部分，均可用break控制循环。break用于强行退出循环。

package struct;
 
public class Breakdemo01 {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }
    }
}

continue:用于终止某次循环，即跳过循环体中未执行的语句，接着进行下一次循环判定。

package struct;
 
public class Continuedemo01 {
    public static void main(String[] args) {
        int i=0;
        while(i<100){
            i++;
            if(i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i+" ");/*1 2 3 4 5 6 7 8 9 
                                     11 12 13 14 15 16 17 18 19 ...*/
        }
    }
}

goto：带标签的break和continue

Java方法

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
设计方法原则：保持方法的原子性，一个方法只完成一个功能

public class demo01 {
    public static void main(String[] args) {
        int a;int b;
        int sum =add(a=1,b=2);
        System.out.println(sum);
    }
    //加法
    public static int add(int a,int b){
        return a+b;
    }
}

tip:static用于调用发法（类变量）

方法的定义

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

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。 return Value Type 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下， return Value Type 是关键字 void 。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
方法体：方法体包含具体的语句，定义该方法的功能。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数- 列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形参：在方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据。

修饰符返回值类型方法名(参数类型参数名){
…
方法体
…
return 返回值;

}

package method;
 
public class demo02 {
    public static void main(String[] args) {
        int a=2;int b=2;
      test(a,b);/*max(a,b)*/
    }
    //比大小的方法
    public static int test/*max*/(int a,int b){
        if(a-b==0){
            System.out.println("a=b");
            return 0;
        }
        if(a-b>0){
            System.out.println(a);
        }else{
            System.out.println(b);
        }
        return 0;
    }
}

方法重载

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

重载规则：

1.方法名称必须相同。
2.参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
3.方法的返回类型可以相同也可以不相同。
4.仅仅返回类型不同不足以成为方法的重载。
实现理论：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对
应的方法，如果匹配失败，则编译器报错。

命令行传参

有时候你希望运行一个程序时候在再传递给给它消息。这要靠传递命令行传参数给main（）函数实现

public class CommandLine
{
    public static void main（String args【】）
    {
        for（int i=0；i<args.length;i++)
        {
            System.out.println（”args【”+i+“】：“+args【i】）；
        }
    }
}

可变参数

在方法声明中，在指定参数类型后加一个省略号（…)
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它
之前声明。

public static void printMax ( double .. numbers )
{
 if ( numbers . length =0)
 {
 System . out . println (" No a Г gunent passed ");
 return;
 }
 double result =numbers[0];
//排序
 for(int i=1;i<numbers.length;++)
 {
1f( numbers[i]>result )
{
 result = numbers [4];
}
 }
 System , out . println (" The max value is ＂+ result );
                         }

递归

A 方法调用 B 方法，我们很容易理解！
递归就是： A 方法调用 A 方法！就是自己调用自己
利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为：
一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

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

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

数组

1.相同类型数据的有序集合。
2.按照一定的先后顺序。
3.一个数据为一个元素，通过下标访问。

声明：
dataType[]arrayRefVar;//首选方法
或
dataType arrayRefVar[];//效果相同但不是首选
创建：
dataType[]arrayRefVar=new dataType[arraySize];
通过索引访问，从0开始
获取数组长度：arrays.length

package array;
 
public class ArrayDemo01 {
    public static void main(String[] args) {
        int[]nums;//声明一个数组
        nums = new int [10];//创建一个数组
        //给数组赋值
        nums [0]=1;
        nums [1]=2;
        nums [2]=3;
        nums [4]=4;
        System.out.println(nums[5]);//输出结果为0，说明默认值为0
        //计算所有元素的和
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        System.out.println(sum);
    }
}

内存分析

栈堆

三种初始化

1.静态初始化

2.动态初始化（手动赋值）

3.默认初始化

package array;
 
public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int a[]={1,12,1,1,1};
        System.out.println(a[0]);
        //动态初始化
        int[] b=new int[10];
        b[0]=1;
    }
}

数组的使用

多维数组

package array;
 
public class ArrayDemo06 {
    public static void main(String[] args) {
        int a[][]={{1,2},{3,4}};//两行两列
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                System.out.println(a[i][j]);
            }
        }
    }
}

arrays类

1.方法都是static修饰的静态方法，在使用的时候直接使用类名进行调用，而不用使用对象来调用

2.具有以下功能：

给数组赋值：通过fill方法
对数组排序：通过sort方法，升序
比较数组：通过equals比较元素值是否相等
查找数组元素：通过binarySearch方法能堆排序好的数组进行二分查找法操作

package array;
 
import java.util.Arrays;
 
public class ArraysDemo05 {
    public static void main(String[] args) {
    int [] a={1,22222,33,44,55,68} ;
        System.out.println(a);//[I@4554617c
        //打印数组元素
        //System.out.println(Arrays.toString(a));
        printa(a);
        System.out.println(" ");
        Arrays.sort(a);//数组进行排序:升序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);//将数组元素全部赋值为0
        System.out.println(Arrays.toString(a));
    }
    public static void printa(int[] a){
        for(int i=0;i<a.length;i++){
            if(i==0){
                System.out.print("[");
            }
            System.out.print(a[i]+",");
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }
        }
    }
}

冒泡排序

package array;
 
import java.util.Arrays;
 
public class ArrayDemo07 {
    public static void main(String[] args) {
        int [] a={22,21,34,54};
        int[] sort = sort(a);//调用完自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(a));//打印数组
    }
    public static int[] sort(int[] a){
        int temp=0;
        //判断要走多少次
        for(int i=0;i<a.length-1;i++){
            //比较判断两个数
            for(int j=0;j<a.length-1-i;j++){
                //由大到小
                /*if (a[j+1] > a[j]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }*/
                //由小到大
                if(a[j+1]<a[j]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
                }
            }
        return a;
        }
    }

稀疏数组

处理方式：

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

面向对象编程

本质：以类的方式组织代码，以对象的组织(封装)数据

抽象

三大特性：封装继承多态

类与对象

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

创建与初始化对象

使用new关键字创建对象

封装

1.高内聚，低耦合

2.数据的隐藏

3.属性私有，get/set

继承

1.本质是对某一批类的抽象

2.Java中只有单继承，没有多继承

3.继承是类和类之间的关系，一个为子类(派生类)，一个为父类(基类)

4.重写(需要有继承关系，子类重写父类的方法)：

1）方法名，参数列表必须相同

2）修饰符：范围可以扩大但不能缩小 public>protected>default>private

3）抛出的异常：范围，可以被缩小，但不能扩大

多态性

1.动态编译：类型：可扩展性

2.多态是方法的多态，属性没有多态

3.父类和子类有联系类型转换异常

4.存在条件：继承关系，方法需要重写，父类引用指向子类对象

father f1=new son();

5.1) static方法，属于类，不属于实例，不能被重写

final常量
private方法

6.instanceof(类型转换)引用类型，判断一个对象是什么类型

static

只执行一次，且优先执行

抽象类

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

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

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

接口

声明接口的关键字是interface

package Oop;
//interface定义的关键字 以下是定义 但并没有实现 接口是实现类
public interface Userservice {
    //接口中所有定义都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update (String name);
    void query (String name);
}

package Oop;
//类 可以实现接口 implements 接口
//实现接口中的类必须要重写接口中的方法
public class UserserviceImpl implements Userservice{
    @Override
    public void add(String name) {
 
    }
 
    @Override
    public void delete(String name) {
 
    }
 
    @Override
    public void update(String name) {
 
    }
 
    @Override
    public void query(String name) {
 
    }
}

内部类

成员内部类、静态内部类、局部内部类、匿名内部类

package Oop.demo02;
 
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();//外部类用new实现
        Outer.Inner inner = outer.new Inner();//内部类通过外部类实现
 
        inner.in();
        outer.out();
        inner.getID();
 
    }
 
}

package Oop.demo02;
 
public class Outer {
    private int id=21220304;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);//21220304
        }
    }
}

异常机制

package excepition;
 
public class demo01 {
    public static void main(String[] args) {
        System.out.println(11/0);//Exception in thread "main" java.lang.ArithmeticException: / by zero
                                  // at excepition.demo01.main(demo01.java:5)
    }
}

三种异常：

检查型异常：编译时不能忽略
运行时异常：可以在编译时忽略
错误：错误不是异常，而是脱离程序员控制的问题

Error

多数与代码编写者操作无关
Java虚拟机运行错误，当JVM不再继续执行所需的内存资源时，将出现OutOfMemoryError
虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）

Exception

在exception分支中有一个重要的子类RuntimeException（运行时异常）
1.ArrayIndexOutOfBoundsException(数组下标越界)
2.NullPointerException(空指针异常)
3.ArithmeticException(算术异常)
4.MissingResourceException(丢失资源)
5.ClassNotFoundException(找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

Error和Exception区别

1.前者是致命的错误，程序无法控制和处理，当出现时，虚拟机会终止线程
2.后者可以用程序处理，避免发生

异常处理机制

异常处理的5个关键字：try、catch、finally、throw、throws

package excepition;
 
public class demo02 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try{//try监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){//catch(想要捕获的异常类型)捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }
         //finally可以不要，假设IO，资源，关闭！
    }
 
}

自定义异常

步骤：
1.创建自定义类
2.在方法中通过throw关键字抛出异常对象
3.若果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
4.在出现异常方法的调用者中捕获并处理异常

package excepition;
//自定义的异常类
public class demo03 extends Exception {
    //传递数字>10
    private int detail;
    public demo03(int a){
        this.detail=a;
    }
    // tostring:异常的打印信息
 
    @Override
    public String toString() {
        return "demo03{"+ "detail="+detail+ "}";
    }
}

package excepition;
 
public class test {
    //可能会存在异常的方法
    static void test(int a) throws demo03 {
        System.out.println("传递的参数为"+a);
        if(a>10){
            throw new demo03(a);//抛出
        }
        System.out.println("ok");
    }
 
    public static void main(String[] args) {
        try {
            test(11);
 
        }catch (demo03 e) {
            System.out.println("demo03=>"+e);
        }
    }
}