投稿
  1. 首页
  2. java

Java尚硅谷核心知识

code • 2022-5-6 • java • 阅读 25

Java尚硅谷核心知识,第1张

这里写目录标题
  • Java基础部分
    • 为什么要为JDK设置环境变量
    • JDK、JRE、JVM
    • Java的关键字和保留字
    • Java的数据类型
      • 强类型和弱类型
      • 基本类型包括：
        • 自动提升以及强制转换
          • 自动提升
          • 强制准换
        • 有byte、short、char的混合运算时结果都为int类型
      • 引用数据类型包括
    • Java文件的执行过程
    • Java的核心
    • Java为什么能够跨平台
    • JVM的组成
    • 运算符
    • 流程控制
    • 数组
      • 二维数组
      • 算法中数组的应用
    • oop--万物皆对象
      • oop三大特性
      • 封装
      • 继承
      • 多态
      • 对象的内存解析
      • 对象数组的内存解析
      • 成员变量（属性）和局部变量
      • 对象数组
      • Java中参数传递
      • 内部类
        • 匿名内部类
      • 构造器constructor
      • this关键字：指向本地的属性、方法和构造器
      • super关键字调用父类中的指定 *** 作
      • 包装类
        • 基本数据类型包装成包装类
      • 关键字static
      • 关键字final
      • 关键字abstract
      • 接口和抽象类的区别
  • 异常处理
    • 异常类型
      • 运行时异常：
      • 编译时异常：
    • 异常处理机制
      • try-catch-finally
      • throws+异常类型
      • 开发中怎么选则哪种处理异常的方式
      • 练习
      • 总结：
  • Java常用的方法解释
    • compare()方法
  • Java中的设计模式
    • 单例(Singleton)设计模式
      • 饿汉式
      • 懒汉式

Java基础部分

Java是一种一次编译，到处运行的语言
Java是一种面向对象的编程语言
Java有一个很大的优势在于有自动回收垃圾的机制

为什么要为JDK设置环境变量

在cmd中可以在任何地方调用JDK指令

JDK、JRE、JVM

JDK是Java开发工具包
JRE是Java运行环境
JVM是Java虚拟机
JDK=JRE+java开发工具（javac.exe（编译）、java.exe（运行））
JRE=JVM+核心类库

Java的关键字和保留字

Java中有很多关键字，保留字是指以后的版本可能会用到（goto和const）
在Java中变量的名字不能关键字或者保留字

Java的数据类型

Java是一种强类型语言

强类型和弱类型

强类型语言：是指强制要求为变量设置类型，在编译前就把数据类型进行确定
弱类型语言：是指是在编译后确定数据类型，没有明显的类型，随着环境的不同，自动变换类型。var a=10;编译前无法确定它的类型。

一共有两种。一种是基本类型，另一种是引用类型

基本类型包括：

byte、short、int、long、float、double、char、boolean

注意：

  • Java中char的范围和c语言中char的范围有区别Java中char占用两个字节，范围是0–65535。
  • 1byte=8bit；
  • long a=12; float b=12;这两种情况不会报错，是因为自动提升的原因
自动提升以及强制转换 自动提升

基本类型中容量小的和容量大的一起运算时，会发生自动提升现象
注意：float的范围比long的还要大。是因为它们底层的存储结构不同。float/double使用科学计数法来存储，而long使用普通的二进制来存储，也就是说一个存的是多少次方，而一个是只有多少位。

强制准换

是指在大容量向小容量转换时发生的，在强制转换时会有精度损失

注意：类型转换都是基本类型之间的，String不能和基本类型之间进行转换，但是包装类可以和String进行转换

有byte、short、char的混合运算时结果都为int类型 引用数据类型包括

String、Array、Interface

Java文件的执行过程

Java的核心
  • JVM
  • 垃圾回收机制：自动监测对象是否超过作用域（可达性分析和引用计数），进行回收
Java为什么能够跨平台

Java语言的运行依赖于JVM，不同的 *** 作系统有不同的JVM

JVM的组成

类加载子系统、运行数据区（内存）、执行引擎、本地接口库，本地方法库

运行时数据区包括：堆、JVM栈、程序计数器、方法区、本地方法栈

JVM栈：用来存储局部变量、对象引用
堆：存放对象实例，用来存储新创建的对象以及数组
方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。有个静态域，用来存储被static修饰的静态方法属性或方法。

运算符
  • 算术运算：+ - * /
  • 赋值运算：
short s=2;
s=s+2;//编译不通过，类型不一致
s+=2;//编译通过，运算时不会改变类型
  • 比较运算
    instanceof
 System.out.println("hello" instanceof String);//true
  • 逻辑运算
&：逻辑与
&&：短路与
|：逻辑或
||：短路或
^：异或。相同为0不同为1
!：非
  • 位运算
<<左移，相当于*2
>>右移，相当于/2
&与运算，都1为1
|或运算，有1为1
^异或运算  110^011=101==>5
~取反运算  ~6=7  (补码)0110<==>(补码)1001==>0111(源码)==>7
  • 三目运算符
    要求 " ："前后两种数据类型要一致
    举个栗子：
//如果a<60,将a的值置为0。
int a=a>60?a:0;
  • 运算符优先级
流程控制
  • 顺序结构
  • 分支结构 :if……else…… switch( ) case:
  • 循环结构:for、where
数组

数组是一种能存储相同数据类型，但是需要占用连续空间数据结构。需要注意的是：长度一旦确定，就不能再进行修改。

注意：数组的索引是从0开始的而数据库库的索引是1开始的，在连接数据库时需要注意。

二维数组

就是两个一维数组组成的数组栈中的引用指向堆，堆中存的也是一个引用

算法中数组的应用
  1. 数组元素的赋值(杨辉三角、回形数等)
  2. 求数值型数组中元素的最大值、最小值、平均数、总和等
  3. 数组的复制、反转、查找(线性查找、二分法查找)
  4. 数组元素的排序算法（稳定性）A和B相等排序后，A和B的次序不变（应用：商品首先根据销量排序，再根据价格排序，就需要排序的稳定性）
oop–万物皆对象

int 不是对象，因为一般情况下创建对象需要进行new。将int转换为包装类后即是对象。
在Java中将功能结构封装在类中，通过类的实例化来调用具体功能结构

主流编程语言要么是面向过程（强调考虑怎么做），要么是面向对象（强调谁来做）。程序员从面向过程的执行者转化成了面向对象的指挥者

举个栗子：把大象装进并冰箱

类：是指对一类事物的概括。
对象：是指存在的一个真实个体

对象一般通过new来创建。类名 对象名 = new 类名();
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰

A a=new A();
A b=a;//a和b指向同一位置，修改b也在修改a
oop三大特性
  • 封装：将属性或方法封装起来，给外界流出访问他的接口，不展现具体细节
  • 继承：一个子类继承一个父类，能够直接调用父类的非私有属性和方法，通过set、get也能访问私有属性。
  • 多态:分为运行时多态（overload）和编译时多态（override），多态的三个必要条件 ：1.要有继承(实现implements) 2.要有重写(overWrite&overRide) 3.父类引用指向子类对象
封装

将方法和属性进行私有化，对实现细节进行隐藏，只暴露出供外界使用的接口

封装的体现：将属性进行私有化，然后通过set和get对属性进行设置和获取

继承

Java是单根继承，一个子类只能继承(extends)一个类。但是可以实现很多个接口

说明：所有的子类都会直接或间接继承Object类

多态

父类的引用指向子类的对象
分为运行时多态（overload）和编译时多态（override）。
编译时，看左边；运行时，看右边
重载
System.out.println()方法就是典型的重载方法，其内部的声明形式如下：

public void println(byte x)
public void println(short x)
public void println(int x)
public void println(long x)
public void println(float x)
public void println(double x)
public void println(char x)
public void println(double x)
public void println()

//这2个方法不能构成重载，会有编译错误。
public int A(int i);
public double A(int i);
//这2个方法可以形成重载
public int A(int i)；
public double A(double i);

重写：子类中可以根据需要对从父类中继承来的方法进行改造

注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

对象的内存解析

对象数组的内存解析

成员变量（属性）和局部变量

形同点：

  • 定义变量的格式相同
  • 都是先声明后使用
  • 都有相应的作用域

不同点：

  • 属性定义在类下，局部变量定义在方法，构造器等内部
  • 属性可以用权限修饰符，局部变量不可以用权限修饰符
  • 属性加载到堆中，局部变量加载到栈中
  • 属性有默认初始值，局部变量没有初始值

对象数组

引用类型：无论是系统提供的还是用户自定义的，在调用时都需要进行实例化来使用

Students []stu=new Students[20];
int n=sc.nextInt();
for(int i=0;i<n;i++){
    stu[i]=new Student();//存在数组里的对象进行实例化
}
Java中参数传递

Java只有值传递

  • 当传递类型是基本类型时，传递的就是参数真实的值，在方法中对值进行修改，不影响本身的值
  • 当传递类型时引用类型时，传递的就是地址的值，在方法中进行修改数据时，会影响本身的值

不是说只要传递的参数是引用类型的就会修改数据的值，他的大前提是传递前后两个引用指向的是同一块内存。

举个栗子：

String s="hello";
Test test=new Test();
test.change(s);
//    change(String s){
//        s="hi";
//    }

System.out.println(s);
内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

通俗的说就是两个类，其中类A包含于类B里面，只有B类需要调用A类，此时就可以将A类写进B类里面，形成内部类。

head类即为person类的内部类
public class person{
    class head{
    
    }
}

内部类分为成员内部类和局部内部类以及匿名内部类

匿名内部类

就是没有名字的一种嵌套类,一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余。

假设当前有一个接口，接口中只有一个方法

public interface Interface01 {
    void show();
}

为了使用该接口的show方法，我们需要去创建一个实现类，同时书写show方法的具体实现方式

public class Interface01Impl implements Interface01{
    @Override
    public void show() {
        System.out.println("I'm a impl class...");
    }
}

如果实现类Interface01Impl全程只使用一次，那么为了这一次的使用去创建一个类，未免太过麻烦。我们需要一个方式来帮助我们摆脱这个困境。匿名内部类则可以很好的解决这个问题。

我们使用匿名内部类

public static void main(String[] args) {
    Interface01 interface01 = new Interface01() {
        @Override
        public void show() {
            System.out.println("这里使用了匿名内部类");
        }
    };
    //调用接口方法
    interface01.show();
}
构造器constructor

构造器非为默认构造器和默认构造器，系统会提供一个默认构造器。
构造器与非构造器之间是重载关系

想要调用另一个类的方法，就需要将类实例化成对象然后调用类里面的方法和属性

this关键字：指向本地的属性、方法和构造器
  • 在类的构造器中，可以使用this()调用本类的其他构造器，在用this进行调用构造器时必须放在第一行
//boy类的marry方法
marry(Girl girl){
       System.out.println("I Love girlA");
}

//girl类的marry方法
marry(Boy boy){
       System.out.println("I Love boyA");
       boy.marry(this);//谁调用marry，this就是谁。boyA回应 I Love girlA
}
  • 我们可以用this来区分属性和局部变量。
this.name = name;
super关键字调用父类中的指定 *** 作

super和this的用法相像，this代表本类对象的引用，super代表父类的内存
空间的标识

包装类

包装类使得一个基本数据类型的数据变成对象，包装类内部有一个cache数组用来进行缓存（0–127）

基本数据类型包装成包装类
  • 装箱
    int i = 500; Integer t = new Integer(i);
  • 拆箱
    Integer a=10;
    int b=a.intValue();
  • 字符串转换成基本数据类型
    int i = new Integer(“12”);
  • 基本数据类型转换为字符串
    String str = 5 + “”;
关键字static

类变量：让一个类的所有实例共享数据
注意：不因对象的不同而改变，将这些属性设置为类属性或者类方法

被static修饰的成员有以下特点：

  • 随着类的加载而加载
  • 优先于对象存在
  • 修饰的成员，被所有对象所共享
  • 访问权限允许时，可不创建对象，直接被类调用

类变量 vs 实例变量内存解析：

说明：首先将所有人的属性置为中国，也可以根据自己的需要进行改变，不进行 *** 作则nation属性为中国

关键字final

被final修饰的变量不能被修改，作为常量出现
被final修饰的类是"太监类"不能被继承
被final修饰的方法也不能被重写

关键字abstract

用abstract关键字来修饰一个类或者方法，这个类叫做抽象类或者抽象方法

抽象方法不能有实现细节

抽象类中可以有非抽象方法

接口和抽象类的区别

实现类在继承父类或者实现接口时候，需要将全部抽象方法进行实现

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。

比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

  • 接口中的常量都是public final static的，方法都是public abstract的，可以省略，系统会自动加上
  • 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
  • 接口可以多继承，抽象类不行
  • 接口定义方法，不能实现，而抽象类可以实现部分方法。
  • 接口中基本数据类型为static 而抽类象不是的。

当你关注一个事物的本质的时候，用抽象类；当你关注一个 *** 作的时候，用接口。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的

所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

异常处理 异常类型 

Java.lang.Throwable
     |--------java.lang.Error：一般不编写针对性代码进行处理
     |--------Java.lang.Exception：可以进行异常处理
         |-------编译时异常（checked）
                 |--------IOException
                        |---------FileNotFoundException
                 |--------ClassNotFoundException
         |--------运行时异常（unchecked）
                 |--------NullPointerException
                 |--------ArrayIndexOutofBoundException
                 |--------ClassCastException
                 |--------NumberFormatException
                 |--------InputMismatchException
                 |--------ArithmaticExceptio
运行时异常： 
//空指针异常
String a=null;
System.out.println(a.charAt(0));

//数组索引越界
int []a=new int[3];
System.out.println(a[3]);

//类型转换异常
Object obj=new Date();
String a=(String) obj;

//NumberFormatException
String str="abc";//如果是String str="123"就不会报错
int num=Integer.parsentInt(str);

//输入不匹配异常
int a=sc.nextInt();//输入非数字就会抛出该异常

//算数异常
int  a=2/0;
编译时异常：

开发过程中的语法、逻辑错误不算异常
异常分为两类：

  • 一类是Error：是指Java虚拟机无法解决的严重问题。如JVM系统内部错误，栈溢出、资源耗尽，内存溢出（OutOfMemory）等等。一般情况下不能进行针对性代码进行处理
  • 另一类是Exception：遇见某些特殊情况才会发生比如1/0会有ArithmeticException，比如空指针、数组越界，类型转换异常。一般情况下，异常指的是Exception。
  • Exception又分为编译时异常和运行时异常。比如：除数为0，数组下标越界等
异常处理机制

有两种方式处理异常：

  • try-catch-finally（是在想办法处理异常）
  • throws+异常类型（是在向上抛出异常，没有真正解决）
try-catch-finally
  • try
    捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现
    异常的代码放在try语句块中。
  • catch (Exceptiontype e)
    在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随
    一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
  • 捕获异常的有关信息：
    getMessage() 获取异常信息，返回字符串
    printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void
  • finally
    捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
    不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行
throws+异常类型

声明抛出异常

开发中怎么选则哪种处理异常的方式 练习


运行结果：

总结：

Java异常处理的抓抛模型：


Java常用的方法解释 compare()方法
  • 当前对象和传入对象相同，返回0
  • 当前对象大于传入对象，返回正数
  • 当前对象小于传入对象，返回负数
Java中的设计模式 单例(Singleton)设计模式

单例模式只生成一个实例，减少了系统性能开销

饿汉式 
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single = new Singleton();
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
return single; 
   } 
}
懒汉式 
class Singleton {
// 1.私有化构造器
private Singleton() {
}
// 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
private static Singleton single;
// 3.提供公共的静态的方法，返回当前类的对象
public static Singleton getInstance() {
if(single == null) {
single = new Singleton();
}
return single; 
    } 
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/798328.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-06
下一篇 2022-05-06

发表评论

登录后才能评论

评论列表（0条）

保存