Question

java关键词及用法

Answer 1

Abstract 抽象的
一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
break
一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行
case

Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
catch
Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
char
Java语言的一个关键字，用来定义一个字符类型

continue
一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
do
一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置
double
一个Java语言的关键字，用来定义一个double类型的变量
else
一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。
final
一个Java语言的关键字。你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。
finally
一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
float
一个Java语言的关键字，用来定义一个浮点数变量
for
一个Java语言的关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。
if
Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。
implements
Java(TM)编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。
import
Java(TM)编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
instanceof
一个二操作数的Java(TM)语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。
int
Java(TM)的一个关键字，用来定义一个整形变量
Java(TM)的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。
long

Java语言的一个关键字，用来定义一个long类型的变量。
private
Java语言的一个关键字，用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。
protected
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。
public
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
return
Java语言的一个关键字，用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。
short
Java语言的关键字，用来定义一个short类型的变量。
static
Java语言的关键字，用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例，并且只能操作类变量。

this
Java语言的关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
throw
Java语言的关键字，允许用户抛出一个exception对象或者任何实现throwable的对象
throws
Java语言的关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。

transient
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
try
Java语言的关键字，用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。同时，一个finally语句块会被执行，无论一个异常是否被抛出。

void
Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。
volatile
Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。

while
Java语言的一个关键字，用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。

关于break和continue。

continue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。

Answer 2

8种数据类型
byte short int long double float char boolean
3种引用类型 接口 interface类class 数组
运算符 +-*/ a++ ++a == || | 或&& &与 true false布尔
a++ 先赋值 在计算
++a 先计算 在赋值
a+=b和 a=a+b不一样 前者自动转换数据类型 后者不自动转

判断if...else if switch...case
三目运算符 ?a:b;

循环for While do..while

数组 int[] x = new int[]; int[] y ={1,3,4};
Int[][] z = new int[][];二维数组

方法 访问权限 是否声明静态 返回类型 方法名(参数){方法体}

主方法的 初始化参数 String args[]

Static 静态修饰符的使用

代码块 静态代码块 static{} 在主方法执行前执行
构造代码块 类名{} 优先于构造方法
普通代码块 {}在方法体内

构造方法 类的构造方法 类名(){} 可以是无参的构造方法

匿名对象 如果一个类的对象只使用一次则使用匿名对象
普通对象实例化
A a = new A();
匿名对象
new A();

方法的重载
方法的方法名一样 参数的 类型不同 或 个数不同 称为方法重载 与返回值无关
Public void show(int i){}
Public int show(){}
Public String show(int age,String name){}

封装性 表示类中的属性或方法不想被外部看到 则使用private声明进行封装
封装后只能在本类中调用 如果 外部想要调用 则使用set get方法
Private name = "Hello";
Private age = 3;

String类的常用方法
1.CharArrays();转换为字符数组
2.Bytescase()转换为比特数组
3.Twim去除字符串中的空格
4.CharAt(x)截取第x位的字符
5.Substring(x)从第x位开始截取字符
6.indexOf(x)从头查找x这个字符 如果没有 则返回-1
7,x.length();字符串长度
8.endsWith("x");字符串是否以x结束
statrsWith("y");字符串是否以 y开头
9.replaceAll("x","y")将该字符串的x全部改成y
10.equalsInoreCase();无视大小写比较2个字符串的内容是否相等
11.UpperCase();//大小写转换
12.Spilt()//拆分字符串
构造方法私有化 单态设计模式
class A{
private A(){
System.out.println("私有的构造方法");
}
public static A a = new A();//在类的内部实例化对象 声明为静态
public static A getA(){//使用方法返回该对象
return a;
}
}
public class Demo01{
public static void main(String args[]){
A a1 = A.getA();
A a2 = A.getA();//在别的类中的静态方法需要使用类名.方法名调用
System.out.println(name());//在本类中的静态方法 不需要类名 直接方法名调用
}
public static String name(){
return "在本类中的静态方法 不需要类名 直接方法名调用";
}
}
继承(extends)与方法的覆写
子类继承父类可以使用父类的所有属性和方法
class A{
String name ="Hello";
int age = 18;
public A(){
System.out.println("父类的无参构造方法默认执行");
}
public void show(){
System.out.println("父类的show");
}

}
class B extends A{
public void show(){
//覆写父类的show方法 访问权限要大于父类的
super.show();//调用父类的show方法
System.out.println("子类的show");
System.out.println("姓名:"+super.name+"年龄:"+super.age);//可以直接使用父类的属性
}
}
public class ExtendsDemo01{
public static void main(String args[]){
B b = new B();//实例化对象
b.show();//调用B类的show方法
}
}
super表示调用父类的方法或属性
父类的无参构造方法是默认调用的

抽象类(abstract)
有一个抽象方法的类叫做抽象类
抽象方法的格式:
abstract 访问权限 返回类型 方法名称 (参数){}
抽象方法没有方法体
抽象类必须有子类
子类如果是普通类 必须实现父类的所有抽象方法

abstract class A{//有一个抽象方法的类叫做抽象类
abstract public void show();//抽象方法没有方法体
}
class B extends A{//继承父类
public void show(){//覆写父类的抽象方法
System.out.println("被实现的抽象方法show");
}
}
public class AbstrDemo01{
public static void main(String args[]){
B b = new B();//实例化B类对象
b.show();//调用show方法
}
}

Final关键字
Final表示最终
final class A{//final声明的类不能有子类
final String name = "Hello";//final声明的属性不可改变
public final void show(){//final声明的方法不能被覆写
name = "MLDN";
System.out.println("此方法不能被覆写");
System.out.println("name"+this.name);
}
}
class B extends A{//
public void show(){
super.show();
System.out.println("覆写的show方法");
}

}
public class FinalDemo01{
public static void main(String args[]){
B b = new B();
b.fun();
}
}

接口interface
接口内只有
全局常量 public static final String NAME = "Hello";//属性名称需要全部大写
可以写成String NAME = "Hello";
抽象方法 public abstract void show();
可以写成 void show();

子类可以实现接口 implements且必须覆写接口中的所有抽象方法
interface A{
String NAME = "Hello";//全局常量
void show();//抽象方法
}
class B implements A{
public void show(){
System.out.println("覆写接口中的show方法");
System.out.println("调用接口中的全局常量:" + NAME);
}
}
public class InterfaceDemo01{
public static void main(String args[]){
B b = new B();
b.show();
}
}

抽象类与接口
子类可以实现多个接口
子类可以继承抽象类
抽象类可以同时实现接口和继承父类
接口可以继承接口 但不能继承抽象类
A implements B,C{}//子类可以实现多个接口
A extends B{}//子类可以继承抽象类
A implements B extends C{}//抽象类可以同时实现接口和继承父类
Interface A extends B,C{}//接口可以继承接口不能继承抽象类

Answer 3

我草