JAVASE基础学习

最新推荐文章于 2024-08-03 17:05:14 发布

Fengkx518

最新推荐文章于 2024-08-03 17:05:14 发布

阅读量532

点赞数

分类专栏： JAVASE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Fengkx518/article/details/122120845

版权

JAVASE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

JAVASE学习路径，主要分三个部分：基础语法+面向对象oop+API

数据类型：Java分为两种数据模式，一种是基本类型，一种是引用类型

可以直白的说除了8大基本类型其他的都是引用类型

基本类型：8大基本类型

byte : 字节类型 -128~127（范围） +-2的 7次方

short : 短整型 -32768~32767（取值范围） +-2的 15次方

int : 整数类型 -21.47~21.47亿（使用范围） +-2的 31次方

long : 长整型大于21.47亿时可以使用long +-2的 63次方

float : 浮点类型单精确，要求精确度不高时可以使用

double : 浮点类型双精确，要求精确度高时使用（java中默认的浮点类型）

char : 字符类型 0~65535，ASCLL码128位 0~127对应的字符编码

boolean : 布尔类型真为true，假为false 逻辑运算

引用类型：除去基本类型都是引用类型

例如：String，类，接口，数组...

基础语法规则：

1.标识符可以有字母，数字，下划线（_），美元符（$）组成，但是不能包含@，%，空格...

2.不能以数字开头例如：class 1Demo 不合理

3.标识符严格区分大小写例如:demo和Demo四两个不同的标识符

4.表示符的命名一般取名要见名知意

5.表示符不可以是Java的关键字

类型转换：

大转小，强制转

小转大，直接转

注释：

// 单行注释

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

运算符：

算术运算符：普通的+ - * / %（取余）++ --

比较运算符：< == > <= >=

逻辑运算符：& | ! && ||

三目运算符：a>0? b:c

赋值运算符：= += -= *= /=

流程控制：

顺序结构：按照顺序从上往下，从左往右依次执行的

分支结构：判断语句

if(){}

if(){}else{}

if(){}else if(){}else if (){}else{} (可以多个else if判断语句进行判断)

选择结构：

switch(){case:语句;brack;default：语句} 出现的每个case后面必须添加brack；表示终止,可以添加多个case进行选择，default表示保底选项，如果上面case都没有选中，最后输出保底选项的语句

循环结构：

for(;;){} 单循环结构

for(;;){for(;;){}} 嵌套循环结构

for(:){} 高效for循环

while(){} 该循环可以用于写死循环，但是后面必须要使用brack; 设置--出口

do()while() 先执行一次，后面再进行判断，如果不符合，就不执行，但是已经执行了一次

数组：

静态创建1： int[] a={1,2,3};

静态创建2： int[] a=new int[]{1,2,3};

动态创建3： int[] a=new int[3];

注意：数组下标是以0开始

面向对象oop

java是一门面向对象语言，所使用的类的都是抽象的，不是唯一的，一个类可以有多个属性和多个方法，如果想要使用该类的属性和方法时，可以在main()创建对象调用方法和属性查看和使用

面向对象的三大特性：封装

用private修饰可以在类里修饰方法和属性，一旦修饰后，该方法和属性设置为私有不可见，只能在本类中查看使用，外界不能查看和使用

面向对象的三大特性：继承

类的继承只有单继承，子类可以继承父类所有的方法属性，除了构造方法，即便是封装后的方法属性也是可以继承下来的，但是不可见

面向对象的三大特性：多态

父类引用指向子类对象

编译看左边，运行看右边

大白话是，父类有的才能使用，但是使用可见的是继承下来的子类的方法和属性

构造方法：

创建对象时使用，有无参构造与含参构造和全参构造

this和super：

this指的是可以调用子类的属性和对象

super指的是可以在子类调用父类的方法和属性

代码块的执行顺序：

静态代码块 -> 构造代码块 -> 构造方法 -> 普通方法->局部代码块

如果普通方法里有局部代码块，局部代码块才会执行

静态代码块：

静态代码块

static{} 随着类的加载而加载，优先于所有加载，常用语初始化，只运行一次

最终

final 被最终修饰的不能改变，不能继承

抽象

abstract 表示是抽象的，如果一个方法时抽象的，那么这个类也必须是抽象方法，

如果继承，那么这个类必须实现这个抽象方法或者这个类也是抽象类

接口

interface 表示是接口，没有构造方法，可以多继承，继承使用implments 接口名

常用语接口开发

异常

异常分为两种，一种是可以处理的异常，一种是不能处理的异常

不能处理的异常：

例如说：电脑蓝屏，电脑死机等等，这种问题是无法处理的

可以处理的异常：

例如说：出现数组下标越界这种问题，只需要把下标重写设置就可以成功运行程序，这种异常是可以处理的

一般处理的方式分为两种：

一种是忘外抛，对于想要引用这个类的程序员来解决这个异常，自己不必解决

一种是自己解决，使用try{预计会报错的代码}catch(异常异常名){解决方法}

内部类

内部类是创建一个类，再在这个类里面创建一个类，这就是内部类

如果在内部类里面想要使用或者调用外部类的方法那么可以在内部类里面直接使用

如果想要在外部类中使用内部类的方法，那么必须要创建一个内部类的对象才能实现使用内部类的方法，否则无法使用

在main()中如果想要创建一个外部内，很简单

a s=new a();

但是想要创建一个内部类的对象时，要知道，创建的是外部类里面的一个类，所以需要new两次

a.b s=new a().new b();

API-基础

在java中api是一个非常重要的东西，因为java是一门面向对象的语言，所以我们使用的都是别人写好的代码，我们进行调用就可以了。

Java中所有的类都会直接或者间接的继承了Object类，因为这个Object这个类是所有类的超类

超类：指的是有可能父类是Object，有可能父类的父类是Object，跟树结构相似，最顶层的就是Object

常见的api有String继承了Object的api

例如：

hashCode() 返回此字符串的哈希码。

equals() 将此字符串与指定的对象比较地址值，如果有toString那么就比较的是属性和值

length() 返回此字符串的长度。

trim() 返回去除首尾空格的字符串

除去这些方法，还有许多的api方法，具体什么作用可以在API手册上查询

StringBuilder与StringBuffer

例如：你想要的打印一句话，打印的是"我的java已经入门了"，让你打印1000次，你会怎么使用java里面的工具呢？

或许有的人会想我会使用for循环我会使用while循环我会使用do-while循环

没有任何毛病，使用这三种循环都可以打印出结果，但是有没有想过如果使用这三种循环的话会用多久的时间打印出来呢？

正常情况下的String打印是会占内存的，打印一次就创建一个新的内存空间

所以面对以上的问题有专门的解决方法，不仅能成功解决，而且还高效，

那就是StringBuilder与StringBuffer，因为使用这两种解决方法在循环时是直接扩内存而不是新建内存，所以不会存在多占内存的问题，执行的时间也比正常情况下的快

包装类

包装类是一个引用类型，除去8大基本类型的都是引用类型，但是呢！包装类是一种特殊的引用类型——因为基本类型只能作为数值展现，根本无法使用，但是包装类是引用类型，是可以使用的，更关键的是基本类型可以转变为包装类型，然后可以使用api

包装类的分类：

byte 的包装类是：Byte

short 的包装类是：Short

int 的包装类是：Integer

long 的包装类是：Long

float 的包装类是：Float

double 的包装类是：Double

char 的包装类是：Character

boolean 的包装类是：Boolean

包装类的创建方式：

Integer a = Integer.valueOf(); 数据只要在-128~127有一个高效的效果
Integer a = new Integer(1); 没有高效的效果，只是创建了一个包装类的对象

自动装箱和自动拆箱

自动装箱：将基本类型转换成包装类型

例如： Integer a=18;

这就是将基本类型int的18转换成为包装类型Integer用一个变量a来保存，然后可以使用a.使用api

自动拆箱：将包装类型转换成基本类型

int b=a; 是将包装类a的值转换为int类型用b的一个变量来保存

底层源码是：int i = a.intValue();

API--高级

IO流

流是什么---流是一种传输数据的一种形式---以程序为始，输入就是从磁盘输入输出到程序中展现，输入就是从程序写入到磁盘中进行保存--使用流一定要加入try{写入可能会出现异常的代码}catch(异常异常名){解决方法}finally{释放流资源}

有两种类型，一种是输入流，一种是输出流

输入流分为两种形式：字符输入流字节输入流

输出流分为两种形式：字符输出流字节输出流

字符输入输出指的是可以输入输出txt文本的内容

字节输入输出指定是可以输入输出所有文件的内容不局限性txt文本文件的内容，也可以是图片，电影等等，因为字节是计算机使用的最小一个单位，电脑可以直接读取，但是读取后的是属于计算机专属的语言，我们无法看懂，想要看懂，可以使用使用IO流展现

序列化与反序列化

与流类似-想要序列化则先要反序列化

序列化表示将程序写入到磁盘中

反序列化表示将磁盘中的数据读取到程序中

一个类的对象如果想被序列化，那么这个类必须实现可序列化接口serializable

集合Collection

集合指的是一个可以容纳数据聚集的结构，与数组类似，但是有区别

数组：可以容纳相同类型的数据，无法增加和删除，使用copeof也不过是在原有的基础上再进行新建一个新的数组，并不是原有的数组进行扩容和缩容

集合：可以容纳不同类型的数据，可以增加和删除

泛型

在集合中起到约束的作用，可以将其约束至只能容纳这一类型的数据进行存储，新增和删除

集合是接口，不能实例化，下面有Set和List也是接口，所以只能通过下方的HashSet，TreeSet，ArrayList，LinkedList 实现类进行实例化对象

ArrayList：底层的是数组结构，查询较快，因为数组有下标，可以通过下标快速查询

数据是有序的，可以存放重复的数据

LinkedList：底层是链表结构，增删较快，常用语首尾操作

Set：HashSet的数据是无序的，可以存入null值，但最多只有一个，常用于去重，如果存入一组相同的数据，那么展示就是那一个数据

集合也有单独的api，具体如何使用可以在API手册中进行查询

Map

Map的实现类是HashMap，创建的是<k,v>键值对，Map的值是无序的，可以用过k来找到指定的value，k的值是唯一的，，v的值是可以重复的，如果存入两个相同的键值对，那么最后存入的那一对键值对会把前面的那一对键值对给覆盖掉

进程与线程

进程指的是电脑，是一个静态的

线程指的是电脑里面的各种程序，是动态的，给程序添加了时间片OS，所以可以运行使用所有的软件，每个程序使用都各部影响，进程有单并发，多并发

单并发：一个进程只是用一个线程

多并发：一个线程使用多个线程

单线程使用run运行

多线程使用start运行，由start进入就绪状态 jvm虚拟机调用线程的run方法，如果中间遇到休眠或者其他阻塞将会重新回到就绪，由jvm虚拟机重新调用run方法运行

多线程的使用：

继承Thread 只能单继承

实现Runnable(一般用于实现接口)：可以多实现，也可以继承其他类

线程池：新建/启动/关闭线程

Executors.newFixedThreadPool(int n);可以创建包含最多n个线程的线程池对象，返回一个ExecutorService，使用pool.excute()来讲线程池中的线程以多线程的方式启动，每次调用都会将一个线程对象加入到就绪队列之中

多线程会出现一种安全隐患--超出范围输出

解决方法:可以加同步锁synchronized解决多线程超出范围输出的安全隐患

注解

JDK自带的注解：

@Override 表示方法的重写，在重写方法上写此注解

元注解：

@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})

表示此注解可以用于类上，属性上，方法上

可以多选，也可以单选，选择后表示此注解只能在指定的位置上使用

注解的生命周期：

@Retention(RentionPolicy.RUNTIME) 在运行时都存在

@Retention(RentionPolicy.SOURCE) 在源文件中存在

@Retention(RentionPolicy.CLASS) 在Class中保存

自定义注解：

@Target() 定义该注解在那些位置上使用

@Retention() 定义该注解的生命周期

@interface+名

设计模式

java中一共存在23种设计模式

其中常用的是单例模式：单例模式确保new的对象只有一个

单例模式有两种表达方式：

饿汉式：顾名思义，直接就new一个对象

package test;
/*本类用于单例模式1：饿汉式
* 总结：饿汉式的方法使用如同银行办业务，有三个业务口，但是就只开了一个口进行业务处理，所以也只能在那一个口进行办业务
* */
public class Demo10 {
    public static void main(String[] args) {
        //3.调用构造方法
      //  Cat c=new Cat();//报错，由于构造方法设置为私有不可见，所以无法创建对象
     //6.  Cat.getCat   //爆红，无法使用，因为main()是static的，静态只能调用静态的方法
        //9.调用
        Cat.getCat();//成功调用
        //11.Cat.cat爆红，对象设置为私有不可见，所以无法查看
        //System.out.println(Cat.cat);//也可以使用类名.创建的对象可以直接调用，相当于调用一次就new一次对象，不符合单例模式，只有一个对象
    }
}
//1.创建一个类
class Cat{
    //2.创建一个私有的构造方法
    private Cat(){
        System.out.println("无参构造");
    }
   //4.创建本类的对象
    //8.添加static
    //10.添加private  设置为私有对象，外界无法调用
  private static Cat cat=new Cat();
    //5.构造方法不可见，创建一个对象供外面使用
    public static Cat getCat(){
        //7.cat爆红，因为本类创建的对象不是静态的
        return cat;
    }
    
}

懒汉式：顾名思义，不直接new对象，需要使用时才new对象

package test;
/*本类用于单例模式2：懒汉式*/

public class Demo11 {
    public static void main(String[] args) {
        //3.创建对象
        //Dog d=new Dog();//报错，因为构造方法设置为私有不可见，所以无法创建对象
        //6.使用对象，因为创建的对象不是static，所以无法使用
        //Dog.getDog();//爆红
        //9.使用对象
        Dog d1 = Dog.getDog();
        Dog d2 = Dog.getDog();
        System.out.println(d1);//test.Dog@677327b6
        System.out.println(d2);//test.Dog@677327b6
        System.out.println(d1==d2);//true


        //System.out.println(Dog.dog);//可以成功使用
    }
}
//1.创建一个类
class Dog{
    //2.创建一个私有的无参构造
    private Dog(){
        System.out.println("无参构造");
    }
    //4.用于保存Dog的地址值
    //8.加入static
    //10.加入private让这个对象成为私有的，外界无法调用
  private static Dog dog;
    //5.创建一个static的方法
    public static Dog getDog(){
        //11.判断是否有调用dog，如果有就执行以下判断
        //12.如果是第一次调用那么默认值为null，如果dog=null就会进入if判断
        if (dog==null){
            //13.如果是第二次调用，那么就无法进入if判断，无法创建新的对象
             dog=new Dog();
        }
        //7.dog爆红--返回对象dog
        return dog;
    }


}