染雾Java知识点总结 篇一
Java是一种面向对象的编程语言，广泛应用于软件开发领域。在学习和应用Java的过程中，有一些重要的知识点需要掌握。本文将对Java的一些核心知识点进行总结和梳理。
1. 数据类型：Java提供了多种数据类型，包括基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型，而引用数据类型包括类、接口、数组等。了解不同数据类型的特点和用法，对于正确使用Java语言非常重要。
2. 运算符：Java提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符等。掌握运算符的优先级和使用方式，能够编写更加高效和灵活的代码。
3. 控制语句：Java提供了多种控制语句，包括条件语句（if-else语句、switch语句）、循环语句（for循环、while循环、do-while循环）和跳转语句（break语句、continue语句）。了解和掌握这些控制语句的使用方法，可以实现不同的程序逻辑和流程控制。
4. 类和对象：Java是一种面向对象的编程语言，类和对象是Java程序的基本组成单元。理解类和对象的概念，掌握类的定义、对象的创建和使用，是学习Java编程的重要基础。
5. 继承和多态：继承和多态是面向对象编程的核心概念。继承可以实现代码的复用和扩展，多态可以实现程序的灵活性和可扩展性。掌握继承和多态的原理和用法，能够编写更加灵活和可维护的Java程序。
6. 异常处理：Java提供了异常处理机制，可以有效地处理程序运行过程中的错误和异常情况。了解异常的分类和处理方式，能够编写更加健壮和可靠的Java程序。
7. 输入输出：Java提供了丰富的输入输出API，可以实现文件读写、网络通信等功能。掌握输入输出的基本操作和常用类库，能够编写更加实用和功能完善的Java程序。
以上是Java的一些核心知识点的总结，掌握这些知识，能够帮助我们更好地理解和应用Java编程语言。
Java知识点总结 篇二
Java是一种广泛应用于软件开发领域的编程语言，具有简单、面向对象、平台无关等特点。在学习和应用Java的过程中，有一些重要的知识点需要掌握。本文将对Java的一些高级知识点进行总结和梳理。
1. 集合框架：Java提供了丰富的集合框架，包括List、Set、Map等常用的数据结构和算法。了解集合框架的特点和使用方式，能够编写更加高效和灵活的Java程序。
2. 多线程：Java支持多线程编程，可以实现程序的并发执行。了解线程的创建、同步和通信机制，能够编写更加高效和可靠的多线程程序。
3. 反射机制：Java提供了反射机制，可以在运行时动态地获取类的信息和调用类的方法。了解反射的原理和用法，能够实现更加灵活和动态的Java程序。
4. 注解：Java的注解机制可以为程序提供额外的元数据信息，用于编写更加灵活和可配置的程序。了解注解的使用方式和常见注解的作用，能够编写更加灵活和易于维护的Java程序。
5. IO/NIO：Java提供了传统的IO和新的NIO两种输入输出方式。了解IO和NIO的特点和使用方式，能够编写更加高效和可扩展的Java程序。
6. 数据库连接：Java提供了数据库连接的API，可以方便地与数据库进行交互。了解数据库连接的原理和使用方式，能够编写更加高效和可靠的数据库应用程序。
7. GUI编程：Java提供了Swing和JavaFX等GUI编程工具包，可以实现图形用户界面的开发。了解GUI编程的基本原理和使用方式，能够编写更加美观和易用的Java程序。
以上是Java的一些高级知识点的总结，掌握这些知识，能够帮助我们更好地使用Java编程语言，并开发出更加高效和可靠的软件应用。
Java知识点总结 篇三
很多初学java的新人不知道哪些java基础知识必须掌握，下面unjs小编为大家精心整理的Java知识点总结，方便大家学习!
1. 基本数据类型
整形：
byte 1 个字节
short 2 个字节
int 4个字节
long 8个字节
字符：
char 2个字节
浮点数：
float 4个字节
double 8个字节
布尔：
boolean 1个字节
2.java 7 新增二进制整数
以0b或者0B开头
3.java中字符时16位的Unicode编码方式，格式是'\uXXXX'，其中xxxx代表一个十六进制整数
4.java中规定了正无穷大、负无穷大和零
正无穷大= 一个正数除以0
负无穷大= 一个负数除以零
0.0 除以0.0 或者 对一个负数开方 得到一个非数
5. 在java中布尔类型只能是true和false
6. 在java中没有多维数组
看似像C语言中的多维数组不是真正的数组，比如 a[3][4] , a[0] a[1] a[2] 是真实存在的，装的是地址，和c语言中动态分配为的数组一样
int [][] b = new int[3][4]
7. Java中带包的编译方法
javac -d . Hello.java 会在当前目录下生成目录树
运行 java 包名字.类名字
8. Java多态中的对象的filed 不具有多态性，如 父类 对象 = new 子类()， 对象.field 是调用的父类的，即使子类中覆盖了该字段，Java知识点总结
。
9. instanceof 运算符
格式： 引用变量名 instanceof 类名(或者接口) 他用于判断前面的对象是否是后面对象的类，子类、实现类的实例，是返回true，否者返回false
10. Java 中基本数据类型和对应封装类之间的转化
int a = 1;
Integer A = new Integer(a);
a = A.intValue();
其他的类型也是这样的。
11.单例(singleton)类 例子
复制代码 代码如下:
class Singleton
{
private static Singleton instance;
private Singleton(){}
public static Singleton getInstance()
{
if(instance == null)
{
instance = new Singleton();
}
return instance;
}
public static void main(String[] args)
{
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
12.final修饰的成员变量初始化问题
类Field： 必须在静态初始块中或声明该FIeld时指定初始值
实例Field：必须在非静态初始块中或声明该FIeld时指定初始值或构造器中声明
13.Final 变量必须显式初始化，系统不会对final变量进行隐式初始化
14.java会使用常量池来管理曾经用过的字符串直接常量，例如：String a = "java"; ，系统把常量字符串“java”存在常量池，当再次执行 String b = "java"; a == b 是true
15.final 方法不可以重写，final类不能被继承
如果用private 方法 和 final private 是一样的
若果是用final修饰的方法在子类中出现，那是子类新定义的，与父类没有关系
16.不可变类：创建后该类的Field是不可改变的。java提供了8个基本变量的包装类和string都是不可改变类。
17.缓存实例的不可改变类
复制代码 代码如下:
class CacheImmutale
{
private static int MAX_SIZE = 10;
private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
private static int pos = 0;
private final String name;
private CacheImmutale(String name)
{
this. name = name;
}
public String getName()
{
return name;
}
public static CacheImmutale valueOf(String name)
{
for(int i = 0; i < MAX_SIZE; ++i)
{
if(cache[i] != null && cache[i].getName().equals(name))
return cache[i];
}
if(pos == MAX_SIZE)
{
cache[0] = new CacheImmutale(name);
pos = 1;
}
else
{
cache[pos++] = new CacheImmutale(name);
}
return cache[pos -1];
}
public boolean equals(Object obj)
{
if(this == obj)
return true;
if(obj != null && obj.getClass() == CacheImmutale.class)
{
CacheImmutale ci = (CacheImmutale)obj;
return name.equals(ci.getName());
}
return false;
}
public int hashCode()
{
return name.hashCode();
}
}
public class CacheImmuteTest
{
public static void main(String[] args)
{
CacheImmutale c1 = CacheImmutale.valueOf("Hello");
CacheImmutale c2 = CacheImmutale.valueOf("Hello");
System.out.println(c1 == c2);
}
}
用缓存实例要看某个对象的使用频率，若重复使用那就利大于弊，若不经常使用那弊就大于利
还有java提供的java.lang.Integer 创建数值在-128-127之间的数采用缓存机制的
Integer in2 = Integer.valueOf(6);
Integer in3= Integer.valueOf(6);
in2 == in3 is true;
18. static 和 abstract 不能同时修饰一个方法，没有类抽象方法
19.一个类可以又一个父类，实现多个接口，接口中Filed是public 、static、final的，方法是public abstract的
20.非静态内部类的方法访问某个变量，搜索顺序为：先内部类中方法内-> 内部类 -> 外部类中如果都找不到则出现编译错误
复制代码 代码如下:
import java.util.*;
public class DiscernVariable
{
private String prop = "外部类的实例变量";
private class InClass
{
private String prop = "内部类的实例变量";
public void info()
{
String prop = "局部变量";
System.out.println("外部类的field值：" + DiscernVariable.this.prop);
System.out.println("内部类的field值：" + this.prop);
System.out.println("局部变量的值：" + prop);
}
}
public void test()
{
InClass in = new InClass();
in.info();
}
public static void main(String[] args)
{
new DiscernVariable().test();
}
}
21.非静态内部类不能有静态方法、静态Field、静态初始化块
22.在外部类之外访问内部类
访问非静态内部类：outclass.Inclass varname = new outclass().new InClass();
访问静态内部类： outclass.Inclass varname = new outclass.Inclass();
复制代码 代码如下:
import java.util.*;
class Out
{
class In
{
public In()
{
System.out.println("非静态内部类构造器");
}
}
}
public class CreatInnerInstance
{
public static void main(String[] args)
{
Out.In in = new Out().new In();
/*
以上的代码可分开写为：
Out.In in;
Out out = new Out();
in = out.new In();
*/
}
}
class SubClass extends Out.In
{
//显示定义SubClass的构造器
public SubClass(Out out)
{
//通过转入的Out对象显示调用In的构造器
out.super();
}
}
复制代码 代码如下:
import java.util.*;
class StaticOut
{
static class StaticIn
{
public StaticIn()
{
System.out.println("静态内部类构造器");
}
}
}
public class CreatStaticInnerInstance
{
public static void main(String[] args)
{
StaticOut.StaticIn in = new StaticOut.StaticIn();
/*
以上的代码可分开写为：
StaticOut.StaticIn in;
in = new StaticOut.StaticIn();
*/
}
}
class SubClass extends StaticOut.StaticIn
{
//无须创建内部类实例
}
