JAVA基础

最新推荐文章于 2023-09-17 16:31:00 发布
最新推荐文章于 2023-09-17 16:31:00 发布
阅读量216 收藏 1
点赞数
分类专栏： 笔记 文章标签： java 开发语言
原文链接：https://edu.csdn.net/skill/java/java-e16c7862e7cc4feeb54cf6a42dd65cef?category=463&typeId=19757
版权

一、关键字总结

1.abstract

  • 修饰类：

abstract修饰类，这个类就是抽象类，抽象类中可以有非抽象变量和成员变量，也可以有普通方法、构造方法。但是不能实例化，只能被子类继承。
如果子类不是抽象类，则必须重写父类的抽象方法。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    ...
}
  • 修饰方法:

abstract修饰方法，这个方法就是抽象方法。抽象方法必须存在于抽象类中。抽象方法不能有具体实现。

abstract public E get(int index);

2.assert

assert表示“断言”，有两种使用方法：

assert 表达式;

若表达式为真，程序继续执行；若表达式为假，则抛出一个AssertionError异常。

assert 表达式:错误信息;

与第一种方法相同，只是异常中带有错误信息。
使用assert时不能在表达式中完成任何程序实际所需的行为（只能做判断）。因为正常发布的代码都是断言无效的，即正常发布的代码中断言语句都不不执行的。

3.boolean

boolean是Java的基本类型之一（默认值false）。只有两个值：true和false。区别C的判断句，Java不能直接使用1和0来表示真假，且boolean类型也不能强转到其他基本类型。

boolean a = true;
boolean b = false;

4.break

  1. break在switch中用于跳出switch块，停止switch向下穿透的现象。
case value:expression;
    break;
  1. break在循环中用于跳出循环。
while(...){
    ...
    break;
}
  1. break也可以在后面接标签，用来跳出一些嵌套比较复杂的循环中。
flag:
for(...){
    for(...){
        break flag;
    }
}

5.byte

byte是Java的基本类型之一（默认值0）。表示8位有符号整数。

范围：-128~127

byte a = 100;

6.case

case用于switch中，用于判断和执行语句。用法：

case 变量值:语句;

若变量值和switch(变量值)
中的变量值相等，就执行后面的语句。执行完后继续执行下一个case语句。

7.catch

catch用于捕获异常。
用法：

catch(异常类型 异常){...}

在try/catch语句块中，catch捕获发生的异常，并应对错误做一些处理。
当catch捕获到异常后，try中执行的语句终止，并跳到catch后的语句中。

8.char

char是Java的基本类型之一（默认值\u000）。表示16位、在Unicode编码表中的字符。使用单引号来表示字符常量，例如’A’。

范围：0-65535

char a = 'A';

9.class

class表示类。用于声明一个类。

[访问控制] (abstract) class 类名 (implements){...}

10.const

const是Java的一个保留关键字，没有实际意义，但是不能用于做变量名（因为被保留作为关键字了）。在C语言中表示常量，类似Java的final。

11.continue

  1. continue用于在循环中跳过本次循环。
while(...){
    ...
    continue;
}
  1. continue也可以在后面接标签，在一些嵌套比较复杂的循环中跳过一次循环。
flag:
for(...){
    for(...){
        continue flag;
    }
}

12.default

default关键字：

  1. 用于switch做默认分支：
default:语句；
  1. 用于接口,让接口实现具体的方法：
public interface a{
    default void b(){
        具体方法;
    }
}

default用于接口时，必须要有具体实现。
(API>=24)

13. do

do用于和while组成循环，do/while循环不同于while循环，属于先执行循环体再判断。

do{
	循环体;
}while(...)

14.double

double是Java的基本类型之一（默认值0.0d），表示双精度、64位的浮点数。

double a = 0.1d;

15.else

else用于分支结构中的判断。例如：

if(判断1){
    语句1;
}else if(判断2){
    语句2;
}else{
    语句3;
}

16.enum

enum表示枚举，用于限制变量值的类型，例如：

public enum Alpha (implements 接口){
    (public static final)a,b,c,d
}

规定Color的实例只能为a,b,c,d其中之一。

枚举类中可以有成员变量和方法。

17.extends

extends表示继承。例如：

class 子类 extends父类{}

Java中的继承是单继承，即子类只能有一个直接父类。
除了private，子类可以访问父类的方法和成员变量。

18.final

  1. 修饰变量：
    将变量变为常量，在初始化变量后不能再改变值。
  2. 修饰方法：
    被final修饰的方法不能被子类重写。
  3. 修饰类：
    被final修饰的类不能被继承。

19.finally

finally在try/catch语句块中处理一些后续的工作。例如关闭网络连接和输入输出流等。

  • 如果在try/catch中使用return，则finally会撤销这个return，无论如何都会执行finally中的语句。

20.float

float是Java的基本类型之一（默认值0.0f）。表示单精度、32位的浮点数。

float a = 0.1f;

21.for

for用于循环:

for(初始化循环变量; 判断执行条件;更新循环变量){
    语句
}
for(变量:数组){
    语句
}

22.goto

Java中的保留关键字，没有实际意义，但是不能用做变量名。在C中表示无条件跳转语句。

23.if

if用于分支结构中的判断。常与else和else if使用。

if(表达式){语句}

若表达式为真，则执行后面的语句。

24.implements

implements用于接入接口。接上接口的类必须实现接口的抽象方法（可以不实现默认方法和静态方法）。

class A implements B{
    @Override
    do(){
        ...
    }
}

25.import

用于导入包。

import android.content.Intent;

26.instanceof

instanceof用于判断类与对象的关系。例如：

a instanceof b

若a是b的一个实例(或子类对象)，则整个表达式的结果是true，否则结果为false。

27.int

int是Java的基本类型之一（默认值为0）。表示32位、有符号的整数。

范围：[-231,231-1)

int a = 1;

28.interface

interface用于声明一个接口，例如：

public interface A{
    void b();
}

声明a为一个接口，若接上该接口，则必须实现其中的抽象方法b。
接口中的成员变量是static、final、public的。接口中的方法为静态方法或默认方法和静态方法(API>=24)。

29.long

long是Java的基本类型之一（默认值为0L），表示64位、有符号的整数。

范围：[-263,263)

long a = 3216846849646L;

30.native

native可以让Java运行非Java实现的方法。例如c语言，要编译后用javah产生一个.h文件。导入该.h文件并且实现native方法，编译成动态链接库文件。在Java加载动态链接库文件，这个native方法就可以在Java中使用了。

public native void aVoid();

31.new

new用于生成类的实例。

Object a = new Object()；

32.package

package用于规定当前文件的包。

package com.example.zhangyijun.testdefactivity;

33.private

访问控制的一种。
私有的方法和变量只能在本类中访问。类和接口不能为私有。

private int a = 1;
private void b(){
    ...
}

34.protected

访问控制的一种。
受保护的方法和变量只能给子类和基类访问。

protected int a = 1;
protected void b(){
    ...
}

35.public

访问控制的一种。
公有的方法、类、变量、接口能够被任何其他类访问。

36.return

方法中返回数据，并结束方法。

37.strictfp

使用strictfp关键字来声明一个类、接口或者方法时，那么该类、接口或者方法会遵循IEEE-754标准来执行，提高浮点运算的精度，并且减少不同硬件平台之间由于浮点运算带来的差异。

public strictfp double aDouble(){
    return 0d;
}

38.short

short是Java的基本类型之一（默认值0）,表示16位、有符号的整数。

范围：[-215,215)

short a = 0;

39.static

static修饰的语句块存放在堆的方法区中。

  1. 静态变量：依附在类中的变量，可以被类的所有的实例共用。
static int a = 0;
  1. 静态方法：依附在类中的方法。静态方法只能访问类中的静态变量和静态方法。
publlic static void b(){
    ...
}
  1. 静态块：在类加载的时候执行块中的语句，块中不能访问非静态变量。
static{
    ...
}
  1. 静态内部类：用static修饰内部类。

40.super

super即超类

  1. 引用父类的的成员：
super.xxx
  1. 变量或方法重名时用super调用父类的成员或方法。
  2. 调用父类的构造方法:
super(xxx);

41.switch

switch用于分支结构，判断某个变量与一系列值是否相等。switch 语句中的变量类型可以是： byte、short、int 、char、String、enum。

switch(变量){
	case value1:语句1;
		break;
	case value2:语句2;
		break;
	...
	default:语句;
}
  1. 若变量和case后的值相等则执行语句。
  2. 当语句执行到break时跳到switch块后，如果没有break会产生穿透现象。
  3. default分支必须为最后一个分支，在没有值和case变量相等时执行该语句。

42.synchronized

synchronized关键字用于保证线程安全。由这个关键字修饰的方法或者代码块保证了同一时刻只有一个线程执行该代码。

synchronized(obj){...}

当一个线程访问同步代码块时，检查obj是否有锁，如果有就挂起。如果没有就获得这个obj的锁，也就是把其他线程锁在了外面。当代码执行完毕时释放该锁，其他线程获得锁继续执行代码。

43.this

  1. 指向当前对象：this.xxx
  2. 形参和成员名字重名时时用this区分。
  3. 引用构造函数。

44.throw

用于抛出一个异常。

throw (Exception);

45.throws

在方法中将发生的异常抛出。

[控制访问](返回类型)(方法名)([参数列表])[throws(异常类)]{...}

46.transient

类接上序列化接口后，可以通过transient关键字将某些变量变得无法序列化。

transient int a = 1;

47.try

在try/catch中，将可能出现异常的语句放在try{}块中，出现异常之后代码将会终止并跳到catch中继续执行。

try{
    ...
}catch(Exception e){
    ...
}finally{
    ...
}

48.void

修饰方法，表示方法没有返回值。

49.volatile

volatile关键字修饰的变量在多线程中保持同步。相比synchronized效率要高，不会阻塞线程。但只能保证数据的可见性，不能保证数据的原子性。例如在处理i++的时候另外一个线程修改i的值，那么i的值将会发生错误，这是原子性导致的。

volatile int a;

50.while

while用于两种循环结构：

while(判读语句){
    循环体...
}

do{
	循环体...
}while(判读语句)

二、查漏补缺

1.多态

多态就是同一个行为，使用不同的实例而发生不同的作用。在使用多态调用方法的时候，编译器检查父类中是否有该方法，如果有才能编译通过，例如：

public class Animals{
    void voice(){动物叫}
}

class Cat extends Animals{
    void voice(){猫叫}
}

public static void testVoice(Animals a){
    a.voice();
}

public static void main(String[] args) {
    testVoice(new Cat())；

    Animals a = new Cat();
    a.voice();
}

猫继承自动物这个类，Animals a = new Cat()是向上转型（父类引用指向子类对象），实际的运行时类型还是Cat，也就是说a instanceof Cat 表达式为真，因此调用a的voice()方法是猫叫。结合C的指针和内存分析来理解多态。

2.泛型

  1. 类型通配符
  • <? extends T>表示该通配符所代表的类型是T类型的子类。
  • <? super T>表示该通配符所代表的类型是T类型的父类
public static <T extends Closable> void close(T... a){
    for(T temp:a){
        try{
            if(temp!=null){
                temp.close();
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}
  1. 泛型不能用在静态属性上
  2. 指定的类型不能为基本类型

3.反射

  1. 获取目标类型的Class对象
Class<?> a = Object.getClass();
Class<?> b = T.class;
Class<?> c = Class.forName(...);

  1. 通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象

    • 不带 "Declared"的方法支持取出包括继承、公有（Public） & 不包括有（Private）的构造函数
    • 带 "Declared"的方法是支持取出包括公共（Public）、保护（Protected）、默认（包）访问和私有（Private）的构造方法，但不包括继承的构造函数
  • Constructor
//a.获取指定的构造函数（公共/继承）
Constructor<T> getConstructor(Class<?>... parameterTypes);
//b.获取所有的构造函数（公共/继承） 
Constructor<?>[] getConstructors(); 
//c.获取指定的构造函数（不包括继承）
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
//d.获取所有的构造函（不包括继承）
Constructor<?>[] getDeclaredConstructors();
  • Field
//a.获取指定的属性（公共/继承）
Field getField(String name);
//b.获取所有的属性（公共/继承）
Field[] getFields();
//c.获取指定的所有属性（不包括继承）
Field getDeclaredField(String name);
//d.获取所有的所有属性（不包括继承）
Field[] getDeclaredFields();
  • Method
//a.获取指定的方法（公共/继承）
Method getMethod(String name, Class<?>... parameterTypes);
//b.获取所有的方法（公共/继承）
Method[] getMethods();
//c.获取指定的方法 （不包括继承）
Method getDeclaredMethod(String name, Class<?>... parameterTypes);
//d.获取所有的方法（不包括继承）
Method[] getDeclaredMethods();

4. 集合

  1. 迭代器遍历ArrayList
Iterator<String> iterator = list.iterator();
while(ite.hasNext()){
    Log.d("TAG",ite.next());
}
  1. 遍历Map
//第一种：map.keySet()
for (String key : map.keySet()) {
    System.out.println("key= "+ key + " value= " + map.get(key));
}

//第二种：map.entrySet().iterator()
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<String, String> entry = it.next();
    System.out.println("key= " + entry.getKey() + " value= " + entry.getValue());
}
      
//第三种：map.entrySet()
for (Map.Entry<String, String> entry : map.entrySet()){
    System.out.println("key= " + entry.getKey() + " value= " + entry.getValue());
}
    
//第四种：map.values()
for (String v : map.values()) {
    System.out.println("value= " + v);
}
  1. 遍历 hashMap() 时 entrySet() 方法是将 key 和 value 全部取出来,所以性能开销是可以预计的, 而 keySet() 方法进行遍历的时候是根据取出的 key 值去查询对应的 value 值, 所以如果 key 值是比较简单的结构(如 1,2,3…)的话性能消耗上是比 entrySet() 方法低, 但随着 key 值得复杂度提高 entrySet() 的优势就会显露出来。
  2. 在只遍历 key 的时候使用 keySet(), 在只遍历 value 的时候使用 values(), 在遍历 key-value 的时候使用 entrySet()。

5.正则

RegexBuddy

  1. 转义字符
\n  \t  \\  \^  \$  \(  \)  \{  
\}  \?  \+  \*  \|  \[  \]
  1. 标准字符集合（大写取反）
\d0~9的任意一个数字
\wA~Z, a~z, 0~9, _中任意一个
\s空格、制表符、换行符等空白符的任意一个
.匹配任意一个字符
[]匹配方括号中任意一个字符
^方括号取反
-方括号中表示范围
{}花括号前正则表达式的重复次数，{m,n}至少m次，最多n次
?花括号后加，非贪婪模式。非花括号后加，相当于{0,1}
+前面的正则表达式至少出现一次，相当于{1,}
*表达式不出现或出现多次，相当于{0,}
^与字符串开始的地方匹配
$与字符串结束的地方匹配
\b匹配一个字符边界
|匹配左边或者右边
(?=exp)断言自身出现的位置的后面能匹配表达式exp
(?<=exp)断言自身出现的位置的前面能匹配表达式exp
(?!exp)断言此位置的后面不能匹配表达式exp
(?<!exp)断言此位置的前面不能匹配表达式exp

6.引用分类

  1. 强引用:StrongReference:引用指向对象，gc运行时不回收
  2. 软引用:SoftReference:gc运行时回收，（jvm内存不够）
  3. 弱引用:WeakReference:gc运行时立即回收
  4. 虚引用:PhantomReference:跟踪对象被回收的状态，必须与ReferenceQueue一起使用
萧篱衣
关注
专栏目录
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
Java--基本数据类型
weixin_44688529的博客
01-05 363
Java提供了八种基本类型，六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型数据类型默认值byte0short0int0long0Lfloat0.0Fdouble0.0d / 0.char‘A’boolean。
Java基础语法
Smuen的博客
01-26 434
一、标识符和关键字 标识符 命名规范： 以字母、数字、下划线 _、**$**符组成，不能以数字开头。 包名要小写、类名各单词首字母大写、变量名和方法名采用驼峰命名法，常量推荐大写、多个单词以_分隔。 关键字 一些被赋予特殊含义的词汇、不能作为标识符 Java中的关键词有： abstract assert boolean break byte case catch char class const continue default do double else enum
Java中double类型保留小数点后两位的方法
喻师傅的学习笔记
09-17 1714
解决java中double类型保留小数点位数问题 Tips： Tips:BIgDecimal的setScale四大常用方法总结：由于会出现类似四舍五不入等问题，idea中已不推荐使用。
C#--依赖注入
weixin_42359607的博客
07-29 1万+
小编在之前面试某家企业时，面试官提出了一个问题，虽然按经验，说出了解决方法，面试官也表示此方法可以实现，且提出了另一种方案，就是“依赖注入”。 面试官的题目是这样子的：如果现在公司有个程序，假设是关于动物园的程序，有些许动物（动物库A）已经加到了动物园里了，里面的动物都完成了动物该有的行为，然后程序已经测试通过，没有问题并已经发布。现在问题是，动物园里要添加新的动物种类，请问，如何不修改动物库A的代码的情况下，将新的动物物种添加到动物园里（题目大概就是这个意思，无非就是说，原来程序不允许修改，只能新增加别
学习Java多态内存分析_JAVA学习笔记14——多态+内存分析
weixin_31201737的博客
03-02 304
最近在看JAVA教学的视频，觉得老师讲的很好，同时借用源代码还有笔记来撰写本系列博客，记录自己的学习内容，同时也供看到的人学习。开始NO.14篇，这篇介绍的是JAVA面向对象的最后一个特征：多态。先来看看多态的具体含义： 多态最直接的表现就是多个子类重写共有父类的一个方法，而在调用这个方法的时候只传入父类的类型，通过向上转型、强制转型等操作又具体到某个子类重写的方法的内容，转而执行那个子类重写的这...
java基础案例教程
01-08
java基础的案例分析和实例教学,适合新手及回顾查阅,对于夯实基础有好处
java基础总结.xmind
03-28
IO、面向对象Object类、API、集合体系、IO体系、面向对象、多线程、递归、相互转换、正则表达式
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JAVA基础加强
12-04
java基础加强版 ，更人性的巩固基础，万丈高楼平地起，只有打好基础，才能理解更复杂的东西
java基础知识图
01-18
总结了java基础的架构，从JDK安装到反射的知识
NutzWk-java基础
最新发布
09-15
WK-V1V5 Java(//) java基础 java基础 java基础 java基础 java基础
JAVA基础自学教程
09-28
写的很详细，适合初学者，里面的讲解很丰富，很有学习价值，最好是配套一本详细的JAVA基础一起看，会有更好的效果
java中的方法
GAOGAOWQ的博客
06-26 271
方法先定义后调用，在main方法外进行定义，在main方法里面进行调用。 带参数方法定义注意：方法调用时，参数的数量与类型与定义中的设置相匹配带参数方法定义数据类型 变量名 = 方法名（参数)注意：方法定义时return后面的返回值与方法定义上的数据要匹配相当方法isEvenNunber执行完后返回了ture，然后将false赋给了falg，所以最后输出为true。方法之间是平级，无法嵌套，void表达无返回值可以不写。return会使代码停止运行，下面代码不再运行。方法通用格式方法的重载重载对应方法的定义
Java编程思想第八章总结+练习
weixin_54932155的博客
10-18 122
多态的作用是消除类型间的耦合。对象可以作为自己本身的类型使用，也可以作为他的基类使用。 练习一： class Cycle{ void print() { System.out.println("Cycle"); } } class Unicycle extends Cycle{ void print() { System.out.println("Unicycle"); } } class Bicycle extends Cycle{ void print() { Syste
面向对象编程答案3
热门推荐
lsqingfeng的博客
11-03 1万+
1. 定义一个动物类，里面有一个方法voice(), 定义一个类Cat,实现voice方法 然后增加一种新的动物类型：Pig(猪)，实现voice()方法。 定义一个Dog类，实现voice方法 定义一个Store（宠物店）类的getInstance方法： 如果传入的参数是字符串dog，则返回一个Dog对象； 如果传入pig，则返回一个Pig对象；否则，返回一个Cat对象。 abstract ...
全面掌握Java基础知识要点
以上便是Java基础知识点的概述，对于初学者而言，理解和掌握这些知识点是学习Java的第一步。通过实践操作，不断编写代码和调试程序，可以逐渐加深对Java语言的理解和应用。同时，这些基础知识点也为后续深入学习Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值