算数运算符 -> “ +,-,*,/,(,)……. “
赋值 -> “ = ”
x = a + b * c / d - e;
自动递增/递减。-> “++/–”
a++;
关系运算符 -> “ > , < ,>= , <= , == , != ”
逻辑运算符 ->. “ && , || , ! ”
if(a > b && e < f && h <= j && p >= q )
if(a != b || c == d)
三元操作符 boolean-expression ? value1 : value2 ==(if(true) value1 else value2)
a > b ? max = a : max = b;
if(a > b)
max = a;
else
max = b;
字符操作符 ->. “ + , += ”
类型转换操作符 (TYPE)
Java没有*sizeof*
类(Class)是面向对象程序设计(OOP,Object-Oriented Programming)实现信息封装的基础。类是一种用户定义的引用数据类型,也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
创建一个类:
class Student{
//成员变量
private String name;
private String number;
private int age;
//成员方法
public Student(){} //无参构造器
public Student(String name,String number,int age){ //全部参数构造器
this.name = name;
this.number = number;
this.age = age;
}
//包外访问private变量的Getter/Setter
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
}
隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别;将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成“类”,其中数据和函数都是类的成员。
继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。
我们发现当某个类的属性方法和一个类很接近时,如果重新仍旧重新写那个类的代码,会导致代码臃肿;所以可以继承自那个类,重写部分方法或修改属性,加入另外独特的方法和属性。
关键字:extends
public class Dog extends Animal{
@Override
void eat(){ //重写吃东西,继承自父类
……
}
void watch(){ //看家本领,独特!
……
}
}
}
前提条件:
多态的成员特点:
成员变量:编译看左边、运行看左边
成员方法:编译看左边、运行看右边
example:
父类Animal,子类Cat
Animal Tom = new Cat();
Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。
example:
//创建接口
package com.sugar.interfaceTest;
/*
* Interface contains:
* 常量
* abstract method
* default method
* static method
* private method
* Tips:
* Abstract method in interface, modifier must be public abstract,and they can be omitted
*/
public interface InterfaceTest {
public static final int greedsWords = 1; //Constant: public static final is needed.
public abstract void greeds();//Abstract method
public default void greedsTwo(){
/*The default method. When upgrading an interface,
if an abstract method is used,
other implementation classes must override the method.
Therefore, the implementation classes put into use need not be modified if the default method is used */
System.out.println("default echo: Hello!");
}
}
----------------------------------------------------------------------------------------------------------------
//创建实现类
package com.sugar.interfaceTest;
public class InterfaceTestImpl implements InterfaceTest {
@Override
public void greeds() {
System.out.println("Hello!");
}
/* 调用这些方法 */
public static void main(String[] args) {
// InterfaceTest interfaceOne =new InterfaceTest(); ----> Wrong
InterfaceTestImpl interfaceOne = new InterfaceTestImpl(); // ---->yes
interfaceOne.greeds();
interfaceOne.greedsTwo();
System.out.println("There " + InterfaceTest.greedsWords + " words in greeds");
}
}
----------------------------------------------------------------------------------------------------------------
//Running结果
Hello!
default echo: Hello!
There 1 words in greeds
Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,也就是说它是有顺序的,类似于数组。和Set不同,List允许有相同的元素。JDK所提供的List容器类有ArrayList、LinkedList等。
// ArrayList测试
import java.util.*;
public class Test{
public static void main(String[] args){
Collection<String> arrayList = new ArrayList<String>();
arrayList.add("China");
arrayList.add(new String("中国"));
System.out.println("size = " + arrayList.size());
System.out.println(arrayList);
}
}
----------------------------------------------------------------------------------------------------------------
Running结果:
size = 2;
[China,中国]
----------------------------------------------------------------------------------------------------------------
// LinkedList测试
import java.util.*;
public class Test{
public static void main(String[] args){
List<String> linkedList = new LinkedList<String>();
for(int i=0;i<=5;i++){
linkedList.add("a"+i);
}
System.out.println(linkedList);
linkedList.add(3,"a100");
System.out.println(linkedList);
linkedList.set(6,"a200");
System.out.println(linkedList);
System.out.println((String)linkedList.get(2)+" ");
linkedList.remove(1);
System.out.println(linkedList);
}
----------------------------------------------------------------------------------------------------------------
Runing结果:
[a0,a1,a2,a3,a4,a5]
[a0,a1,a2,a100,a3,a4,a5]
a2
[a0,a2,a100,a3,a4,a200]
Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2) = false,Set最多有一个null元素。
Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。 Set容器类主要有HashSet和TreeSet等。
// 测试HashSet
import java.util.*;
public class TestC{
public static void main(String[] args){
Set <String> hashSet = new HashSet<String>();
hashSet.add("Hello");
hashSet.add("Hello");
System.out.println(hashSet);
}
}
----------------------------------------------------------------------------------------------------------------
Running结果:
[Hello]
值得注意的是Map没有继承Collection接口,Map接口是提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个value.即是一一映射,Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。 Map接口的实现类主要是包括HashMap和TreeMap等。
import java.util.*;
public class TestD{
public static void main(String[] args){
Map <String,String> hashMap = new HashMap <String,String>();
hashMap.put("one",new String("1"));
hashMap.put("two",new String("2"));
System.out.println(hashMap);
}
}
----------------------------------------------------------------------------------------------------------------
Running结果:
<two=2,one=1>
Java容器实际上只有三种:Map , List, Set;但每种接口都有不同的实现版本.
异常指不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。异常是一个事件,它发生在程序运行期间,干扰了正常的指令流程。Java通过API中Throwable类的众多子类描述各种不同的异常。因而,Java异常都是对象,是Throwable子类的实例,描述了出现在一段编码中的 错误条件。当条件生成时,错误将引发异常。
在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常 处理的重要子类,各自都包含大量子类。
Error(错误): 是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 不再有继续执行操作所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的,因为它们在应用程序的控制和处理能力之 外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过Error的子类描述。
Exception(异常):是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。
通常,Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。
可查的异常(编译器要求必须处置的异常):
不可查异常(编译器不要求强制处置的异常):
运行时异常:
都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生
运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。
非运行时异常 (编译异常):
在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。
抛出异常:当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。
一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常。简单地说,异常总是先被抛出,后被捕捉的。
捕获异常:try、catch 和 finally
try-catch语句
在Java中,异常通过try-catch语句捕获。其一般语法形式为:
try {
// 可能会发生异常的程序代码
} catch (Type1 id1){
// 捕获并处置try抛出的异常类型Type1
}
catch (Type2 id2){
//捕获并处置try抛出的异常类型Type2
}
tips:一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。一经处理结束,就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
try {
// 可能会发生异常的程序代码
} catch (Type1 id1) {
// 捕获并处理try抛出的异常类型Type1
} catch (Type2 id2) {
// 捕获并处理try抛出的异常类型Type2
} finally {
// 无论是否发生异常,都将执行的语句块
//常用来关闭资源等收尾必须做的工作
}
tips:try 块:用于捕获异常。其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
catch 块:用于处理try捕获到的异常。
finally 块:无论是否捕获或处理异常,finally块里的语句都会被执行。当在try块或catch块中遇到return语句时,finally 语句块将在方法返回之前被执行。在以下4种特殊情况下,finally块不会被执行:
1 在finally语句块中发生了异常。
2 在前面的代码中用了System.exit()退出程序。
3 程序所在的线程死亡。
4 关闭CPU。
任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。
throws抛出异常
void method1() throws IOException{} //合法
//编译错误,必须捕获或声明抛出IOException
void method2(){
method1();
}
//合法,声明抛出IOException
void method3()throws IOException {
method1();
}
//合法,声明抛出Exception,IOException是Exception的子类
void method4()throws Exception {
method1();
}
//合法,捕获IOException
void method5(){
try{
method1();
}catch(IOException e){…}
}
//编译错误,必须捕获或声明抛出Exception
void method6(){
try{
method1();
}catch(IOException e){throw new Exception();}
}
//合法,声明抛出Exception
void method7()throws Exception{
try{
method1();
}catch(IOException e){throw new Exception();}
}
throw抛出异常
throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。例如抛出一个IOException类的异常对象:
throw new IOException;
要注意的是,throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的:这是因为String 不是Throwable 类的子类。
throw new String("exception");
如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。
package Test;
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int a = 3;
int b = 0;
try { // try语句包含可能发生异常的语句
int result = quotient(a, b); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
注意:catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型,e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause():返回抛出异常的原因。如果 cause 不存在或未知,则返回 null。
getMeage():返回异常的消息信息。
printStackTrace():对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值,
runtimeException子类
java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
java.lang.ArithmeticException 算术条件异常。譬如:整数除零等。
java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。
java.lang.NegativeArraySizeException 数组长度为负异常
java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
java.lang.SecurityException 安全性异常
java.lang.IllegalArgumentException 非法参数异常
IOException
IOException:操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
其他
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外,用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可。在程序中使用自定义异常类,大体可分为以下几个步骤:
创建自定义异常类:一般会选择继承Exception和RuntimeException,如果不要求调用者一定要处理抛出的异常,就继承RuntimeException。
抛出自定义异常:在方法中通过throw关键字抛出异常对象。
捕获自定义异常:如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作。
在出现异常方法的调用者中捕获并处理异常
class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
@Author
@Date $2020/ 07 / 15 / 16 : 03 : 35 $
参考文献来自于
CSDN
百度百科
本文地址:https://blog.csdn.net/Sugar2247945677/article/details/107363110
如对本文有疑问, 点击进行留言回复!!
现在微服务这么火,你还不了解吗?阿里P8推荐的微服务学习指南
论文笔记:SlowFast Networks for Video Recognition
网友评论