Java知识点
第一章 Java语言概述
Java的特点
开源、跨平台
Java运行平台
- Java SE Java标准版，普通桌面和商务应用程序
- Java EE Web应用程序开发
- Java ME 电子消费产品和嵌入式设备
JDK，JRE，JVM关系
使用JDK开发完成的java程序，交给JRE去运行，JVM保证跨平台
第二章 基本数据类型和数组
2.1标识符
- 字母、下划线、美元符号和数字组成，并且第一个字符不能是数字
- 标识符不能是关键字
- 标识符不能是true、false和null（true，false，null不是关键字）
关键字
常用的关键字：abstract、assert、boolean、break、byte、case、catch、char、class、const、continue、default
、do、double、else、enum、extends、final、finally、float、for、goto、if、implements、import、instanceof、
int、interface、long、native、new、package、private、protected、public、return、short、static、strictfp、
super、switch、synchronized、this、throw、transient、try、void、volatile、while
2.2基本数据类型
-
逻辑类型
- 常量：true、false
- 变量的定义：使用关键字boolean来定义逻辑变量
-
整数类型
- 常量：123，6000（十进制数），077（八进制数），0x3ABC（十六进制数）
- int类型（4字节）
- byte字型（1字节）
- short类型（2字节）
- long类型（8字节）
-
字符类型
- char类型（2字节）
-
浮点类型
- float类型（4字节）
- double类型（8字节)
2.3基本数据类型的转换
精度从低到高：
1.byte<short<int<long<float<double
2.char<int<long<float<double
2.4 数据的输入与输出
1. 数据输出System.out.printf
2. 数据的输入Scanner
1. import java.util.*;
2. Scanner reader=new Scanner(System.in);
3. double x=reader.nextDouble();
2.5数组
-
声明数组
- 数组元素类型 数组名[]; float a[];
- 数组元素类型[] 数组名; float[] a;
- 创建数组
- 数组名字=new 数组元素的类型[数组元素的个数]; boy=new float[4];
- 数组元素的使用
- 数组的初始化
- length的使用
- 数组名字.length （数组元素的个数），对于二维数组，数组名字.length的值是一维数组的个数
- 数组的引用
第三章 运算符、表达式和语句
3.1算术运算符和算术表达式
- 加减运算符
- 乘、除和求余运算符
- 自增、自减运算符
- 算术表达式
- 算术混合运算的精度
3.2关系运算符和关系表达式
- 大小关系运算符
- 等与不等关系
- 关系表达式
3.3逻辑运算符和逻辑表达式
- 逻辑与和逻辑或
- 逻辑非
- 逻辑表达式
3.4赋值运算符和赋值表达式
3.5移位运算符
- 左移位运算符<<
- 右移位运算符>>
3.6位运算符
- 按位与运算符
- 按位或运算符
- 按位非运算符
- 按位异或运算符
向左位运算(<<)
乘2
例：4<<2: 4乘2乘2=16
向右位运算(>>)
除2
例：15>>3: 15/2/2/2=3
3.7条件运算符
3.8 instanceof运算符
- 运算结果是true，否则是false
3.9一般表达式
3.10语句概述
- 方法调用的语句
- 表达式语句
- 复合语句
- 控制语句
- package语句和import语句
3.11分支语句
-
条件分支语句
- if-else语句
- 多条件if-else语句
-
switch开关语句
switch(表达式){ case 常量值1：若干语句 break; case 常量值2：若干语句 break; ...... case 常量值n:若干语句 break; default:若干语句 } 常量值1~n必须是整型或字符型，在同一个switch语句中，case后的常量值必须互不相同
3.12循环语句
-
while循环
while(表达式){ 若干语句 } -
do-while循环
do{ 若干语句 }while(表达式); -
for循环
for(表达式1;表达式2;表达式3){ 若干语句 }
3.13跳转语句
跳转语句是指用关键字break或continue加上分号构成的语句
运算符优先级
标识符命名规则
第四章 类和对象
4.1面向对象编程
1.面向对象编程的三个特性
- 封装
- 继承
- 多态
2.提出一个简单的问题
-
例4-1 计算圆的面积
public class ComputerCircleArea{ public static void main(String args[]){ double radius;//半径 double area;//面积 radius=163.16; area=3.14*radius*radius;//计算面积 System.out.printf("半径是%5.3f的圆的面积:\n%5.3f\n",radius,area); } }
3.简单的Circle类
class Circle{
double rsdius;//圆的半径
double getArea(){//计算面积的方法
double area=3.14*radius*radius;
return area;
}
}
4.使用Circle类创建对象
Circle c=new Circle();//创建对象
5.Java应用的程序的基本结构
- Java应用程序由若干个类构成，但必须有一个主类，即包含main方法的类
- Java应用程序总是从主类的main方法开始执行
- Java程序以类为基本单位，一个Java程序由若干类构成
4.2类声明和类体
class 类名{
类体
}
4.3类体的构成
- 属性：成员变量
- 功能：方法
4.4构造方法和对象的创建
- 构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型
- Java允许一个类中有若干个构造方法，但这些构造方法的参数必须不同，或者是参数的个数不同，或者是参数的类型不同
class Rect{
double sideA,sideB;
Rect(){}//无参数构造方法
Rect(double sideA,double sideB){//有参数构造方法
this.sideA=sideA;
this.sideB=sideB;
}
}
-
对象的声明
-
类的名字 对象名字
-
例：Rect r;(r是声明对象的名字，没有引用任何实体，称为空对象)
-
-
为声明的对象分配成员变量
-
r=new Rect();
-
r=new Rect(10,20)
-
为成员变量分配内存空间，然后执行构造方法中的语句（整型成员变量的默认初值：0；浮点型：0.0；boolean：false；引用型：null）
-
给出一个信息，确保这些成员变量是属于对象r
-
-
-
创建多个不同的对象
-
使用Rect类创建两个对象rOne和rTwo
- rOne =new Rect(10,20);
- rTwo =new Rect(33,66);
4.使用对象
- 对象操作自己的变量（对象的属性）
- 对象调用类中的方法（对象的行为）
- 体现封装
4.5对象的引用和实体
4.6成员变量
-
属性：
-
成员变量：在类中方法外
-
类变量：static 类名 变量
static int y;//类变量 -
实例变量：new 对象 变量
double above,height;//实例变量 -
常量：final 赋值
final int PI=3.14;//常量
-
-
局部变量：在方法内或者方法声明上
-
4.7方法
-
方法声明和方法主体
float area(){ } -
实例方法(必须通过对象调用)
-
不用关键字static修饰的称为实例方法
float min(folat a){ return a ; }
-
-
类方法(可以通过类名调用)
-
用关键字static修饰的称为类方法或者静态方法
static float max(float a){ return a ; }
-
-
参数传值
- 基本数据类型参数的传值：不可以高的类型传递给低的(例：不可以int的值传给float)
- 引用类型参数的传值
4.8方法重载
-
方法重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数个数不同或者参数的类型不同
-
如果两个方法的名字相同，即使类型不同，也必须保证参数不同
class People{ double getArea(double x,int y){ return x*y; } int getArea(int x,double y){ return (int)(x*y); } double getArea(float x,float y,float z){ return (x*x+y*y+z*z)*2.0; } } public class Example4_10{ public static void main(String ages[]){ People a=new People(); System.out.println("面积："+a.getArea(10,3.88)); System.out.println("面积："+a.getArea(10.0,8)); } }
4.9关键字this
- 可以在实例方法和构造方法中，但不能在类方法中
4.10 包
- 包语句
- package 包名（如果源程序中省略了package语句，源文件中所定义命名的类被隐含地认为是无名包的一部分，即源文件中定义命名的类在同一个包中，但该包没有名字）
第六章 内部类、匿名类与Lambda表达式、异常类、
6.5 Class类
6.5.1 Java反射
Class是java.lang包中的类，Class的实列封装和类有关的信息。
Class对象调用如下的方法可以获取当前类的有关信息，例如，类的名字、类中的方法名称、成员变量的名称等，这一机制也成为Java反射。
第七章 面向对象设计的基本原则
7.1 UML类图简介
UML类图属于结构图，常被用于描述一个系统的静态结构。
一个UML类图中通常包含：
①类(Class)的UML图
②接口(Interface)的UML图
③泛化关系(Generalization)的UML图
④关联关系(Association)的UML图
⑤依赖关系(Dependency)的UML图
⑥实现关系(Realization)的UML图
⚫类的UML图
长方形垂直地分为三层
⚪第一层是名字层
名字是常规字形，表明该类是具体类，如果名字是斜体字形，表明该类是抽象类
⚪第二层是变量层
⚪第三层是方法层
⭐访问权限：+表示public
-表示private
#表示protected
⚫接口(Interface)
⚫泛化关系(Generalization)
继承关系
⚫关联关系(Association)
组合关系
⚫依赖关系(Dependency)
⚫实现关系(Realization)
7.2 面向抽象原则
7.2.1 抽象类和接口
1.抽象类
特点：
- 抽象类中可以有abstract方法，也可以有非abstract方法
- 抽象类不能用new运算符创建对象
- 如果一个非抽象类是某个抽象类的子类，那么它必须重写父类的abstract方法
- 做上转型对象，尽管抽象类不能用new运算符创建对象，但它的非abstract子类必须重写它的所有abstract方法，这样一来，就可以让抽象类声明的对象成为其子类对象的上转型对象，并调用子类重写的方法。
2.接口
特点：
- 接口中可以有public权限的abstract方法、default方法和static方法
- 接口由类去实现，即一个类如果实现一个接口，那么它必须重写接口中的abstract方法
- 接口回调：接口回调指把实现接口的类的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法
代码块
（1）static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
（2）类什么时候被加载
①创建对象实例时(new)
②创建子类对象实例，父类也会被加载
③使用类的静态成员时(静态属性，静态方法)
（3）普通的代码块，在创建对象实例时，会被隐式的调用。
被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行。
（4）创建一个对象时，在一个类调用顺序是：(重点，难点)
①调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
②调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用
③调用构造方法
枚举
1.自定义枚举
- 不需要提供set方法，因为枚举对象值通常为只读
- 对枚举对象/属性使用final+static共同修饰，实现底层优化
- 枚举对象名通常使用全部大写，常量的命名规范
- 枚举对象根据需要，也可以有多个属性
/**
* @author DFshmily
* @version 1.0
*/
public class enumeration {
public static void main(String[] args) {
System.out.println(Season.SPRING);
}
}
class Season{
private String name; //季节名称
private String description; //季节描述
public final static Season SPRING = new Season("春天","温暖");
public final static Season SUMMER = new Season("夏天","炎热");
public final static Season AUTUMN = new Season("秋天","凉爽");
public final static Season WINTER = new Season("冬天","寒冷");
private Season(String name, String description) {
this.name = name;
this.description = description;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
@Override
public String toString() {
return "Season{" +
"name='" + name + '\'' +
", description='" + description + '\'' +
'}';
}
}
结果：
Season{name='春天', description='温暖'}
小结：
1）构造器私有化
2）本类内部创建一组对象[四个 春夏秋冬]
3）对外暴露对象（通过为对象添加public final static修饰符）
4）可以提供get方法，但是不要提供set
2.enum关键字实现枚举
public class enumeration1 {
public static void main(String[] args) {
System.out.println(Season1.SPRING);
}
}
enum Season1{
/*
如果使用了enum来实现枚举类
1.使用关键字enum来代替class
2.public final static Season2 SPRING = new Season("春天","温暖");直接使用
SPRING("春天","温暖") 解读 常量名（实参列表）
3.如果有多个常量（对象），使用，号间隔即可
4.如果使用enum来实现枚举，要求将定义常量对象，写在前面
*/
SPRING("春天","温暖"),
SUMMER("夏天","炎热"),
AUTUMN("秋天","凉爽"),
WINTER("冬天","寒冷");
private String name;
private String desc;//描述
private Season1(){//无参构造器
}
Season1(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
@Override
public String toString() {
return "Season1{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
运行结果：
Season1{name='春天', desc='温暖'}
enum关键字实现枚举注意事项：
-
当我们使用enum关键字开发一个枚举类时，默认会继承Enum类，通过使用javap工具演示
-
传统的public static final Season2 SPRING = new Season2(”春天“,"温暖");简化成SPRING(”春天“,"温暖")，这里必须知道，它调用的是哪个构造器
-
如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略
-
当有多个枚举对象时，使用间隔，最后有一个分号结尾
-
枚举对象必须放在枚举类的行首
注解
1.注解的理解
1）注解（Annotation）也被称为元数据（Metadata）用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息
2）和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息
3）在javaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的角色，例如用来配置应用程序都任何切面，代替java EE旧版中所遗留的繁冗代码和XML配置等
2.基本的Annotation介绍
使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
🌟三个基本的Annotation：
1）@Override：限定某个方法，是重写父类方法，该注解只能用于方法
2）@Deprecated：用于表示某个程序元素（类，方法等）已过时
3）@SuppressWarnings：抑制编译器警告
基本的Annotation应用案例
🤙@Override注解的案例：
public class override1 {
public static void main(String[] args) {
}
}
class Father{//父类
public void fly(){
System.out.println("Father fly...");
}
public void say(){
}
}
class Son extends Father{//子类
/*
1.@Override 注解放在fly方法上，表示子类的fly方法时重写了父类的fly
2.这里如果没有写@Override还是重写了父类fly
3.如果你写了@Override注解，编译器就会去检查该方法是否真的重写了父类的
方法，如果的确重写了，则编译通过，如果没有构成重写，则编译错误
*/
@Override //说明
public void fly(){
System.out.println("Son fly...");
}
@Override
public void say(){}
}
⛔补充说明：@interface的说明
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
@interface 不是interface，是注解类，在jdk1.5之后加入的
🤙Override使用说明
- @Override表示指定重写父类的方法（从编译层面验证），如果父类没有fly方法，则会报错
- 如果不写@Override注解，而父类仍有pubilc void fly(){}，仍然构成重写
- @Override只能修饰方法，不能修饰其他类，包，属性等等
- 查看@Override注解源码为@Target(ElementType.METHOD)，说明只能修饰方法
- @Target是修饰注解的注解，称为元注解
🤙@SuppressWarnings：注解是jse提供的注解。作用是屏蔽一些无关紧要的警告。使开发者能看到一些他们真正关心的警告。从而提高开发者的效率
java.lang.SuppressWarnings是J2SE 5.0中标准的Annotation之一。可以标注在类、字段、方法、参数、构造方法，以及局部变量上。作用：告诉编译器忽略指定的警告，不用在编译完成后出现警告信息。
使用：
@SuppressWarnings(“”)
@SuppressWarnings({})
@SuppressWarnings(value={})
示例：
· @SuppressWarnings(“unchecked”)
告诉编译器忽略 unchecked 警告信息，如使用List，ArrayList等未进行参数化产生的警告信息。
· @SuppressWarnings(“serial”)
如果编译器出现这样的警告信息：The serializable class WmailCalendar does not declare a static final serialVersionUID field of type long，使用这个注释将警告信息去掉。
· @SuppressWarnings(“deprecation”)
如果使用了使用@Deprecated注释的方法，编译器将出现警告信息。使用这个注释将警告信息去掉。
· @SuppressWarnings(“unchecked”, “deprecation”)
告诉编译器同时忽略unchecked和deprecation的警告信息。
· @SuppressWarnings(value={“unchecked”, “deprecation”})
等同于@SuppressWarnings(“unchecked”, “deprecation”)
二、 @SuppressWarings注解
作用：用于抑制编译器产生警告信息。
示例1——抑制单类型的警告：
@SuppressWarnings("unchecked")
public void addItems(String item){
@SuppressWarnings("rawtypes")
List items = new ArrayList();
items.add(item);
}
示例2——抑制多类型的警告：
@SuppressWarnings(value={"unchecked", "rawtypes"})
public void addItems(String item){
List items = new ArrayList();
items.add(item);
}
示例3——抑制所有类型的警告：
@SuppressWarnings("all")
public void addItems(String item){
List items = new ArrayList();
items.add(item);
}
三、注解目标
通过 @SuppressWarnings 的源码可知，其注解目标为类、字段、函数、函数入参、构造函数和函数的局部变量。
而家建议注解应声明在最接近警告发生的位置。
四、抑制警告的关键字
| 关键字 | 用途 |
|---|---|
| all | to suppress all warnings （抑制所有警告） |
| boxing | to suppress warnings relative to boxing/unboxing operations（抑制装箱、拆箱操作时候的警告） |
| cast | to suppress warnings relative to cast operations（抑制映射相关的警告） |
| dep-ann | to suppress warnings relative to deprecated annotation（抑制启用注释的警告） |
| deprecation | to suppress warnings relative to deprecation（抑制过期方法警告） |
| fallthrough | to suppress warnings relative to missing breaks in switch statements（抑制确在switch中缺失breaks的警告） |
| finally | to suppress warnings relative to finally block that don’t return（抑制finally模块没有返回的警告） |
| hiding | to suppress warnings relative to locals that hide variable |
| incomplete-switch | to suppress warnings relative to missing entries in a switch statement (enum case)(忽略没有完整的switch语句) |
| nls | to suppress warnings relative to non-nls string literals(忽略非nls格式的字符) |
| null | to suppress warnings relative to null analysis(忽略对null的操作) |
| rawtypes | to suppress warnings relative to un-specific types when using generics on class params(使用generics时忽略没有指定相应的类型) |
| restriction | to suppress warnings relative to usage of discouraged or forbidden references |
| serial | to suppress warnings relative to missing serialVersionUID field for a serializable class(忽略在serializable类中没有声明serialVersionUID变量) |
| static-access | o suppress warnings relative to incorrect static access（抑制不正确的静态访问方式警告) |
| synthetic-access | to suppress warnings relative to unoptimized access from inner classes（抑制子类没有按最优方法访问内部类的警告） |
| unchecked | to suppress warnings relative to unchecked operations（抑制没有进行类型检查操作的警告） |
| unqualified-field-access | to suppress warnings relative to field access unqualified（抑制没有权限访问的域的警告） |
| unused | to suppress warnings relative to unused code（抑制没被使用过的代码的警告） |
