java自学笔记（一）

最新推荐文章于 2024-06-29 11:40:58 发布

期待未来的男孩

最新推荐文章于 2024-06-29 11:40:58 发布

阅读量185

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/u012391293/article/details/124289408

版权

JAVA 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

JAVA

JDK、JRE、JVM
在这里插入图片描述

安装环境

下载JDK Java Downloads | Oracle
安装JDK
配置环境变量 jdk 、jre 变量
验证
helloworld

卸载JDK

删除java安装目录
删除JAVA_HOME
删除path下关于java的目录
java -v

安装IDEA

https://www.jetbrains.com/zh-cn/idea/download/ 下载连接

JAVA 基础语法

注释

   		//单行注释
        //输出一个hello world

        /*
        * 块注释 注释多行
        * */

        /**
         * @Dsecription helloworld
         * @Author lxf
         */

标识符

关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t0ixQFZW-1650418499891)(../../图片/typora/1650417569316.png)]

大小写敏感
字母、 $下划线开始后面可以接字母、数字、_、$ 任意组合

数据类型-强类型语言

基本类型

public class Demo02 {
    public static void main(String[] args) {
        //8大基本数据
        int num1 = 1;
        byte num2 = 20;
        short num3 = 3;
        long num4 = 4L;
        //小数
        float mun5 = 5;
        double num6 = 6;
        //字符
        char name = 'a';
        //字符串
        String a="hellowrold";

        //布尔值
        boolean flag = true ;
   }
}

public class Demo03 {
    public static void main(String[] args) {
        //整数进制  二进制ob 十进制 八进制o 十六禁止0x
        int i = 10;
        int i2 = 010;
        int i3 = 0x10;
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=====================");
        //=============================================
        //银行业务  BigDecimal 数学类工具
        //float 有限 离散 舍入误差 大约  接近但不等于
        // double
        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f==d);
        float d1 = 232222222222222222F;
        float d2 = d1 + 1;
        System.out.println(d1==d2); // true
        //=================================================
        //字符
        //==================================================
        System.out.println("=====================");
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int) c2);
        //所有字符都是数字
        //编码 unicode 表 ：（a=97） 2字节 0-65535 Excel 2^16=65535
        //U000 UFFFF

        char c3 ='\u0061';
        System.out.println(c3);
        //转移字符
        //\t  制表符
        //\n 换行
        //。。
        System.out.println("=====================");


    }
}

public class Demo04 {
    public static void main(String[] args) {
        int i = 128 ;
        byte b = (byte)i ;
        //强制转换  高精度   到   低精度
        //自动转换  低精度   到   高精度
        System.out.println(i);
        System.out.println(b);
        /*
        * 1.不能对布尔类型强制转换
        * 2.不能把对象类型转换为不相干的类型
        * */
        System.out.println("=============================");
        System.out.println((int)23.7);
        System.out.println((int)-45.67f);
        System.out.println("=============================");
        char c = 'a';
        int d = c + 1;
        System.out.println(d);
        System.out.println((char) d);
    }
}

引用类型

变量规范

见名知意
驼峰原则 LastName
局部变量首字母小写
类名首字母大写
方法名首字母小写

运算符

package operator;

public class Demo02 {

    public static void main(String[] args) {
        long a = 123123123123L;
        int b = 123 ;
        short c = 10 ;
        byte d = 8 ;
        System.out.println(a+b+c+d);
        System.out.println(b+c+d);
//        System.out.println((String)(c+d));
        System.out.println(Math.pow(2,3));
        System.out.println(++d);
        System.out.println(d++);
        System.out.println(d);
        int q = 10 ;
        int w = 20 ;
        int e = 5 ;
        //字符串连接 + String
        System.out.println(""+q+w);
        System.out.println(q+w+"");
        System.out.println(q<w?"及格":"不及格");
        System.out.println(q+w*e);
    }
}

包

一般使用公司域名的倒置作为包名

package com.lxf.operator.base;
import com.lxf.base.*;

javadoc\

方法1 命令模式 javadoc -encoding UTF-8 -charset UTF-8 Doc.java
在这里插入图片描述

方式2 通过IDEA

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0QzmKciN-1650418499892)(../../图片/typora/1649307307142.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fxKIvkv6-1650418499893)(../../图片/typora/1649307325277.png)]

JAVA 流程控制

Scanner

package com.lxf.ui;

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

顺序结构

选择结构

if

Scanner scanner = new Scanner(System.in);
if (scanner.hasNextInt()){
    int a = scanner.nextInt();
    System.out.println("你输入的为："+ a );
}

switch

   char grade = 'C';
        switch (grade){
            case 'A' :
                System.out.println("优秀");
                break;
            case 'B' :
                System.out.println("良好");
                break;
            case 'C' :
                System.out.println("及格");
                break;
            default:
                System.out.println("未知");
        }

反编译
在这里插入图片描述

循环结构

while

int i = 0 ;
        while ( i < 100 ){
            ++i ;
            System.out.println(i);
        }

do while

for

for (int i = 0 ; i < 100 ; i++){
            System.out.println(i);
        }

public class IfDemo02 {
    public static void main(String[] args) {
        /*
        打印9*9乘法表
         */
        for (int i = 1; i < 10; i++) {
            for (int j = i; j < 10; j++) {
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
        for (int i = 1; i < 10; i++) {
            for (int j=1; j <= i; j++) {
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SBkPfBTu-1650418499894)(../../图片/typora/1649313451091.png)]

break continue

break 跳出循环

continue 退出本次循环

goto 跳转到tag位置继续执行

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

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

值传递、引用传递定义

public class StringBase {
 
    public static void main(String[] args) {
        int c = 66; //c 叫做实参
        String d = "hello"; //d 叫做实参
 
        StringBase stringBase = new StringBase();
        stringBase.test5(c, d); // 此处 c 与 d 叫做实参
 
        System.out.println("c的值是：" + c + " --- d的值是：" + d);
    }
    
    public void test5(int a, String b) { // a 与 b 叫做形参
        a = 55;
        b = "no";
    }
package com.oop;

//引用传递：对象本质还是值传递
public class Demo02 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        Demo02.change(person);
        System.out.println(person.name);
    }
    //定义一个person 类 有一个属性name
    static class Person{
        String name ;
    }
    public static void change(Person person){
        person.name = "lxf";
    }

}

【运行结果】
c的值是：66 — d的值是：hello

可以看出通过方法传递后，int 类型与 String 类型的原值并没有受到前面 test5 方法执行后的影响，还是输出了原值。这种形为通常被说成值传递。如果原值经过 test5 方法后被改变了，这种形为通常被描述为引用传递。
定义

- **值传递**：指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
- **引用传递**：是指在调用函数时将实际参数的地址直接传递到函数中(的形参)，那么在函数中对参数所进行的修改，将影响到实际参数。
- **引用传递**：形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。(下面文章中 C++ 的定义,我觉得这样说更精简形象一些，所以放了两个定义，其实意思是一样的)

方法的重载

package com.lxf.method;

public class Demo01 {
    public static void main(String[] args) {
        int max = max(1,2);
        System.out.println(max);
        double max1 = max(10.0,20.0);
        System.out.println(max1);

    }
   public static int max(int a , int b){
        if (a > b){
            return a;
        }else {
            return b;
        }
    }
    public static double max(double a , double b){
        if (a > b){
            return a;
        }else {
            return b;
        }
    }
}

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

方法的重载的规则：

方法名称必须相同。
列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以成为方法的重载。

实现理论：

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对
应的方法，如果匹配失败，则编译器报错。

递归

递归机构包含两个部分

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

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

数组

数组长度确定
元素不能是混合类型
元素可以是基本类型或者引用类型
数组可以看成是对象
保存在堆中
ArrayIndexoutboundExceptions 数组越界异常下标超出数组长度

package com.lxf.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] b = {1,2,3,4,25,6,7,8,9,10};
        //打印数组
        for (int arrary : b){
            System.out.print(arrary+" ");
        }
        System.out.println();
        printArray(b);
        System.out.println();
        reserse(b);
    }
    //打印数组
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
    //反转数组
    public static void reserse(int[] args) {
        int a = 0;
        for (int i = 0; i < args.length/2; i++) {
            a = args[i];
            args[i] = args[args.length-1-i];
            args[args.length-1-i]=a;
        }
        printArray(args);
    }
}

多维数组

package com.lxf.array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[][] b = {{1,2},{1,2},{3,4},{25,6},{7,8},{9,10}};
        //打印数组
        System.out.println();
        printArray(b);
    }
    //打印数组
    public static void printArray(int[][] arrays){
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length;j++)
            System.out.print(arrays[i][j]+" ");
        }
    }
}

应用

排序-八大排序方法

冒泡排序

package com.lxf.array;

import java.util.Arrays;

public class ArrayDemo05 {
    public static void main(String[] args) {
    int[] a = {12,32,44,767,2222,12,2,222,1245};
    int[] sort= sort(a);
    System.out.println(Arrays.toString(sort));

    }

    public  static int[] sort(int[] array){
        int c = 0;
        boolean flag = false;
        for (int i = 0; i < array.length-1; i++) {
            for (int j=0; j < array.length-1-i;j++){
                if (array[j]>array[j+1]){
                    c = array[j];
                    array[j]=array[j+1];
                    array[j+1]=c;
                    flag = true ;
                }
            }
            if (flag = true){
                break;
            }
        }
        return array;
    }
}

稀疏数组

package com.lxf.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        // 11*11的棋盘 1：黑棋 2：白棋
        int[][] arrary = new int[11][11];
        arrary[1][2] = 1;
        arrary[2][3] = 2;
        System.out.println("输出原始数组");
        for (int[] ints :arrary){
            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 (arrary[i][j]!=0){
                    sum = sum + 1;
                }
        }
        System.out.println("有效值个数为："+sum);

        int[][] arrary2 = new  int[sum + 1][3];
        arrary2[0][0] = 11;
        arrary2[0][1] = 11;
        arrary2[0][2] = sum;   
        
        //便利数组将非零数存到稀疏数组中
        int count = 0;
        for (int i = 0; i < arrary.length; i++) {
            for (int j = 0; j < arrary.length; j++) {
                if (arrary[i][j] != 0){
                    count++;
                    arrary2[count][0] = i;
                    arrary2[count][1] = j;
                    arrary2[count][2] = arrary[i][j];
                }
            }
        }
        //输出
        System.out.println("输出稀疏数组");
        for (int i = 0; i < arrary2.length; i++) {
            System.out.println(arrary2[i][0]+"\t"+arrary2[i][1]+"\t"+arrary2[i][2]+"\t");
        }
        System.out.println("=======还原数组=============");
        int[][] arrary3 = new int[arrary2[0][0]][arrary2[0][1]];
        for (int i = 1; i < arrary2.length; i++) {
            arrary3[arrary2[i][0]][arrary2[i][1]]=arrary2[i][2];
        }
        System.out.println("打印还原数组");
        for (int[] ints :arrary3){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

在这里插入图片描述

面向对象

以类的方式组织代码，以对象的组织（封装数据）

三大特性：封装、继承、多态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9nOCi8ym-1650418499896)(../../图片/typora/1649379496506.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rHJdpiId-1650418499898)(../../图片/typora/1649383140946.png)]

构造函数

package com.oop.Demo03;
// java ------>  calss
public class Person {
    //一个类即使什么都不屑 他也会存在一个方法
    //显示的定义构造器
    String   name ;
    int age ;
    /*
    实例化初始值
    使用 new 关键字必须要有构造器 本质实在调研构造器
    alt insert  构造函数快捷键
     */

    
    public Person(){
        
    }
    //有参的构造函数
    public Person( String name){
        this.name = "asd";
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(int age) {
        this.age = age;
    }
}


package com.oop.Demo03;

public class Application {
    public static void main(String[] args) {
        //new 关键字生成一个class 文件 实例化一个对象
//        Person person = new Person( qqq);

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XDSRSB1h-1650418499898)(../../图片/typora/1649416941981.png)]

封装

高内聚低耦合
属性私有 get set
alt insert 快捷键

package com.oop;

public class Demo05 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("lxf");
        System.out.println(s1.getName());
        s1.setAge(100);
        System.out.println(s1.getAge());
    }

    public static class Student {
        /*
        名字、学号、性别、学习、睡觉
         */
        private  String name;
        private  int id;
        private  int age;
        private  char sex;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName(){
            return this.name;
        }        public  void setName(String name){
            this.name = name;
            }
        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;
        }
    }
}

继承

继承的关键字 extends
ctrl h 查看类的继承关系

    public static class Student extends  Person{
        /*\
        pulic protected default priovate
         */
    }
      //java所有类 都默认继承object 类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jA7EPRwz-1650418499899)(../../图片/typora/1649420710144.png)]

方法重写

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，抛出 IOException 异常或者 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

多态

可扩展性
多态是方法的多态和属性没关系
父类和子类有联系类型转换异常
存在的条件：继承关系方法需要重写父类应用指向子类对象 father f1 = new son（）；
static 方法属于类不属于实例
final 常量
private 私有方法只属于类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-USMykZix-1650418499901)(../../图片/typora/1649422420825.png)]

Static

static 最先加载只加载一次
然后匿名加载每创建一个对象就会加载一次
最后才是构造函数

抽象类

不能 new
抽象类的所有方法必须由子类去重写
接口可以多继承
抽象类可以写普通方法
抽象方法只能在抽象类中
有构造方法

public abstract class A{ 
    
}

接口

约束和实现分离

接口本质的契约 interface

没有构造方法

public interface InterfaceDemo01 {
    void run ();
}


public class UserServiceImpl implements  InterfaceDemo01{
    @Override
    public void run() {        
    }

内部类

异常机制

检查性异常、运行时异常、错误、

抛出异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jp6Lj95K-1650418499902)(../../图片/typora/1649428027163.png)]

捕获异常

关键字： try、catch、finally、throws

package com.oop1.Demo02;

public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {//监控 ：要发生异常的代码块
            System.out.println(a/b);
        }catch (ArithmeticException e){  // 捕获异常
            System.out.println("程序出现异常1");
        }catch (Exception e){  // 捕获异常
            System.out.println("程序出现异常2");
        }catch (Throwable e){  // 捕获异常
            System.out.println("程序出现异常3");
        }finally {
            System.out.println("finall");
        }

    }
}

ctrl alt t

在这里插入图片描述

期待未来的男孩

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java自学笔记（一）

JAVAJDK、JRE、JVM安装环境下载JDK Java Downloads | Oracle安装JDK配置环境变量 jdk 、jre 变量验证helloworld卸载JDK删除java安装目录删除JAVA_HOME删除path下关于java的目录java -v安装IDEAhttps://www.jetbrains.com/zh-cn/idea/download/ 下载连接JAVA 基础语法注释 //单行注释 //输出一个hel
复制链接

扫一扫