JAVA基础学习

最新推荐文章于 2024-10-06 20:16:20 发布

菜鸟驿站0925

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量151

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_42778639/article/details/120442925

版权

持续性学习，坚持！
学习视频：狂神说Java】Java零基础学习视频通俗易懂

win快捷键

win键(微软图标键)+E键打开桌面
win键(微软图标键)+tab 窗口视图
【Ctrl、Shift和Esc】即可打开任务管理器

DOS命令

切换盘符：直接输入D:回车
查看当前目录下所有文件：dir
切换路径：cd
退出：exit
ip:ipconfig
ping +网址
创建文件：md + 文件夹名
删除文件夹：rd
创建文件：cd> 文件名
删除：del +文件名

第一步 HelloWorld

public class Hello {
    public static void main (String[] args){
        System.out.println("HelloWorld");
    }
}

注：

输入psvm 然后按tab 就可以自动生成 public static void main (String[] args)
直接输入sout，自动出现提示System.out.println
1.java大小写敏感
2.尽量使用英文
3.文件名大写首字母，文件名和类名一致
4.符号使用英文

注释

单行注释 //
多行注释 /* 注释*/
文档注释 /**注释*/

标识符

关键字
java所有组成部分都需要名字。类名、变量名以及方法名称都被称为标识符。
所有的标识符都是以字母、$、_开始
标识符大小写敏感
可以中文、但不建议

数据类型

强类型语言：所有变量先定义后使用
基本类型
- 数值类型（primitive type）
  - 整数类型
    - byte 1个字节范围： -128–127 （-2^7 ～ (2^7-1)）
    - short 2个字节范围：-32768–32767 （-2^15 ~ (2^15-1)）
    - int 4字节范围： -2147483648–2147483647（ -2^31 ~ (2^31-1)）
    - long 8字节后面加L 范围：（-2^63 ~ (2^63-1)）
  - 浮点类型
    - float 4字节后面加F
    - double 8字节
  - 字符 char 2字符
- boolean类型
  - true\false 占1位
  注意：金额用BigDecimal
引用类型(reference type)
- 类
- 接口
- 数组
类型转换
1.低----》高 byte，short，char—int–long—float–double
2.定义一个比较大的数时避免内存溢出，精度问题
3.强转换：（类型）变量名高-》低
4自动转换：低–》高
5.不能对布尔值进行转换

变量

每个变量先声明其类型
每一个声明必须完整，有分号;
变量是程序中最基本存储单位，其要素包括变量名，变量类型和作用域；
类变量、实例变量（方法外面、类里面，从属于对象）、局部变量（方法里面）

public class Demo04 {//类
    //类变量 static
    static double salary =2500;
    //属性：变量
    //实例变量：从属于对象，如果不自行初始化，这个类型默认值 0 0.0 u000 布尔值默认false 除了基本类型其他默认值都是Null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须生命和初始化值
        int i =10;
        System.out.println(i);
        //变量类型 变量名字=new Demo04();
        Demo04 demo04 =new Demo04();
        System.out.println(demo04.age);
        System.out.println(demo04.name);
        //类变量
        System.out.println(salary);
    }
    //其他方法
    public void add(){

    }
}

变量命名规范

在这里插入图片描述

常量

初始化后不能再改变值！常量名一般使用大写字符
final 常量名 =值;
final double PI =3.14

public class Demo05 {
    //修饰符，不存在先后顺序
    static final double PI =3.14;
    final static double PP = 3.1415;
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(PP);
    }
}

运算符

在这里插入图片描述
算数运算符计算结果类型为计算值中的高位类型；
关系运算符返回结果为布尔值；

           int a= 3;
           int b=a++;//执行完这行代码后，先给b赋值，再自增
            System.out.println(a);//4

            int c=++a;//执行代码前先自增，再给c复制
            System.out.println(a);//5
            System.out.println(b);//4
            System.out.println(c);//5
            double pow = Math.pow(2, 3);//Math类:2*2*2,幂运算
            System.out.println(pow);//8

x?y:z
如果x==true，则结果为y，否则结果为z

数组

数组是相同类型数据的有序集合
数组描述的是相同类型的若干数据，按一定的先后次序排列组合而成
其中，每个数据称作一个数组元素，每个元素可以通过一个下标来访问它们，从0开始
必须声明数组变量，才能在程序中使用

int[] nums;//1.定义,常用，声明数组
        //int nums2[];//定义

使用new操作字符创建数组

        nums =new int[7];//创建数组，这里面可以存放7个int类型数字

数组的元素是通过索引访问，从0开始
获取数组长度 arrays.length

public static void main(String[] args) {
        int[] nums;//1.定义,常用
        nums =new int[7];//这里面可以存放7个int类型数字
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        //计算所有元素的和
        int sum =0;
        for (int i = 0; i <nums.length ; i++) {
            sum +=nums[i];
        }
        System.out.println("总和为"+sum);
    }

内存分析

堆
栈
方法区

流程控制

顺序结构

if选择结构

switch选择结构

while循环结构

先判断后执行

do while 循环结构

先执行后判断

for循环结构

for (int i = 0; i < 100; i++) {
       //100.for+enter，快捷方式     
        }

/***
         * 九九乘法表
         * 1.打印第一行
         * 2.那固定的1在用一个循环包起来
         * 3.去重：i<=j
         * 4.调整样式
         */
        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循环

  int[] numbers ={10,20,30};
        //遍历数组元素
        for(int x:numbers){
            System.out.println(x);
        }

break 和continue区别

1.break强制跳出循环，不终止循环以外的程序；
2.continue 终止某次循环，跳过循环体中尚未执行的语句，继续进行下一次循环判断

//打印三角形
        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();
        }

方法

命名规则：首字母小写驼峰命名
1.方法是语句的集合，它们在一起执行一个功能；
2.方法是用来解决一类问题步骤的有序组合；
3.方法包含于类或对象中；
4.方法在程序中被创建，在其他地方被引用；
5.原则：一个方法只完成一个功能，保持原子性；

在这里插入图片描述
一般情况下，定义一个方法包含以下语法：

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

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

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

方法调用

在这里插入图片描述
静态（static）方法：类名.方法名；staitc与类一同存在。
非静态方法：对象名.方法名；类实例化之后才存在。
return：终止方法，返回一个结果。

方法重载

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

方法重写

A a = new A();
静态方法：方法的调用只和左边有关，定义的数据类型有关
非静态方法：子类重写了父类方法

重写前提：需要有继承关系，子类重写父类的方法
方法名必须相同，方法体不同
参数列表必须相同
修饰符：范围可以扩大，但是不能缩小，public >protected>default>private
抛出异常：范围可以被缩小，不能扩大

递归

A方法调用自己。

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
一旦你定义了自己的构造方法，默认构造方法就会失效。

public class MyClass {
        int x;
        //构造函数
        MyClass(){
            x=10;
        }
        //调用构造方法来初始化一个对象：
    public static void main(String args[]) {
        MyClass t1 = new MyClass();
        MyClass t2 = new MyClass();
        System.out.println(t1.x + " " + t2.x);
    }
}

public class MyClass {
        int x;
        MyClass(int i){
            x=i;
        }
    public static void main(String args[]) {
        MyClass t1 = new MyClass(10);
        MyClass t2 = new MyClass(20);
        System.out.println(t1.x + " " + t2.x);
    }
}

package oop;

public class Person {
    String name;
    //实例化初始值
    //1.使用new关键字必须要有构造器，本质是调用构造器
    //2.使用初始化值
    public Person(){}
    //2.有参构造,一旦定义有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;//this.代表当前类，=值一般为参数传进来的值
    }
}
// package oop;
//
//public class Application {
//    public static void main(String[] args) {
//        Person person = new Person("nana");
//        System.out.println(person.name);//null
//构造器：1.和类名相同；2.没有返回值
// 作用：new本质调用构造方法，初始化对象值   }
//}

alt+insert:默认生成有参构造器。

面向对象

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

public class Student {
    //属性：字段
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
/***
 * public class Application {
 *     public static void main(String[] args) {
 *         //类是抽象的，需要实例化
 *         //类实例化后会返回一个方法
 *         //student对象就是一个Student类的具体实例
 *         Student student = new Student();
 *         student.name="小米";
 *         student.age=10;
 *         System.out.println(student.name);
 *         System.out.println(student.age);
 *
 *     }
 * }
 */

}

封装

意义：
1.提高程序安全性，保护数据；
2.隐藏代码的实现细节
3.统一接口
4.提高系统的可维护性

继承

Java只有单继承，没有多继承
关键字：extends，所有的类都默认直接/间接继承object类
子类继承了父类就会有父类的全部方法，私有的东西无法被继承
-super注意点
1.super调用父类的构造方法，必须在构造方法的第一个；
2.super只能出现在子类的方法或构造方法中；
3.super 和this不能同时调用构造方法
super vs this
代表对象不同：
this :本身调用者这个对象
super:代表父类对象的应用
前提：
this:没有继承也能用
super:继承条件下次才能使用
构造发法：
this：本类的构造
super：父类的构造

多态

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常！
存在的条件：有继承关系，方法需要重写，父类引用指向子类对象

抽象类

abstract 关键字；
抽象类的所有方法，继承了它的子类都必须要实现它的方法；
抽象类不能New,只能靠子类实现；

接口

package demo09;
//关键字interface，接口都需要实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

实例：

/*
 接口的作用
  1.约束
  2.顶一下一些方法，让不同人实现
  3.接口是抽象的
  4.接口不能被实例化，没有构造方法
  5.通过implements可以实现多个接口
  6。必须要重写接口中的方法
 */
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 demo09;

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);
        }
    }
    //局部内部类
    public void method(){
        class Inner2{
            public void in1(){
            }
        }
    }
}
//一个Java类中可以有多个class类，但是只有一个public
class A{

}

package demo09;

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

异常机制

Exception
文件找不到、网络连接失败、非法参数
检查型异常：用户错误引起，程序无法预见
运行时异常RunTimeException
错误ERROR
在这里插入图片描述
抛出异常、捕获异常

package demo09;

public class Demo01 {
    public static void main(String[] args) {
        int a =1;
        int b =0;
        try {//监控区域
          //new Demo01().a();
            System.out.println(a/b);
        }catch (Error e){//捕获异常
            System.out.println("Error出错啦~");
        }catch (Exception e){//捕获多个异常，需要从小到大，最后的最大
            System.out.println("Exception");
        }catch (Throwable e){
            System.out.println("Throwable");
        }finally {//处理善后工作，可以不要
            System.out.println("finally");
        }
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }


}

package demo09;

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

}

工具类

com.google.common.base.Preconditions
org.apache.commons.io.IOUtils
org.apache.commons.io.FileUtils
org.apache.commons.lang.StringUtils
org.apache.commons.lang3.StringUtils
org.springframework.util.StringUtils
org.apache.http.util.EntityUtils
org.apache.commons.io.FilenameUtils
org.apache.commons.lang.ArrayUtils
org.apache.commons.lang3.ArrayUtils
org.apache.commons.lang.StringEscapeUtils
org.apache.http.client.utils.URLEncodedUtils
org.apache.commons.codec.digest.DigestUtils
org.apache.commons.collections.CollectionUtils
org.apache.commons.beanutils.PropertyUtils
org.apache.commons.beanutils.BeanUtils
org.apache.commons.lang3.StringEscapeUtils

时间类

java.util.Date
表示一个特定瞬间，精确到毫秒；
Date()分配一个Date对象，并初始化对象作为系统当前日期和时间；
下面是一个如何实例化java.util.Date的例子：

//创建时间 类
java.util.Date date = new java.util.Date();

Date实例包含了当前时间作为它的日期和时间。
你可以通过getTime()方法访问java.util.Date实例的日期和时间，比如像这样：

java.util.Date date = new java.util.Date();
long time = date.getTime();

你也可以用一个以毫秒为单位的时间作为来源来创建一个java.util.Date实例，比如像这样：

long now = System.currentTimeMillis();
java.util.Date date = new java.util.Date(now);

如果你需要获取或者设置年、月、日、小时等，则使用java.util.Calendar，
一个给定的日期上添加或者减少年数、月数、天数、小时数。

package oop;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class Gong {
    public static void main(String[] args) {
        Calendar calendar = new GregorianCalendar();
        //set date to last day of 2009
        calendar.set(Calendar.YEAR, 2009);
        calendar.set(Calendar.MONTH, 11); // 11 = december
        calendar.set(Calendar.DAY_OF_MONTH, 31); // new years eve
        //add one day
        calendar.add(Calendar.DAY_OF_MONTH, 1);

        int year = calendar.get(Calendar.YEAR);  // now 2010
        int month = calendar.get(Calendar.MONTH); // now 0 (Jan = 0)
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); // now

        System.out.println(year);
        System.out.println(month);
        System.out.println(dayOfMonth);

    }
}

通过调用带有负值的add方法在这些字段上减少值，比如：

calendar.add(Calendar.DAY_OF_MONTH, -1);

格式日期：java.util.DateFormat

//格式日期
SimpleDateFormat sim = new SimpleDateFormat("yyyy年MM月dd日");
//测试 格式化当前日期
System.out.println("当前时间：");
System.out.println(sim.format(date));

时间比较（compareTo）

菜鸟驿站0925

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

JAVA基础学习

win快捷键

DOS命令

第一步 HelloWorld

注释

标识符

数据类型

基本类型

数值类型（primitive type）

整数类型

浮点类型

字符 char 2字符

boolean类型

true\false 占1位

引用类型(reference type)

类

接口

数组

类型转换

变量