1.基本结构:
public static void main(String[] args) {
权限修饰符、静态修饰符 返回值类型 方法名 参数
}
2.fload类必须加上F、f否则编译器会当成double
3.final常量,可以先定义在赋值,但只能赋值一次
4.static
static方法:不依赖于任何对象就可以访问,故没有this操作,静态方法中不可访问非静态方法和变量,反之可以。
补充:当然也可以将某个类的实例对象,然后通过该实例对象调用非静态方法
static变量:不可修饰局部变量,同样不需要依托于对象(与C语言不同,static不可限制权限),两个对象对同一个静态成员变量操作,将会操作内存中的同一个地址
5.String:
字符串常用方法:indexOf()该字符串第一次出现的位置
lastIndexOf()该字符串第一次出现的位置
charAt()指定位置的字符
subString(1,3)截取字符串
trim()去除前导空格和尾部空格
replace(”A”,”B")替换字符串
startsWith()endsWith()是否是这个前缀或者后缀
compareTo()按照字典顺序比较两个字符串,基于Unicode值
例:
String str1 = "test11";
String str2 = "test22";
str2.compareTo(str1)返回“1”,相反“-1”,相同则“0”
split(”,”,3)按照指定字符和次数限制分割字符串
equals()对比两个对象(必须是地址和内容全部相同)
例:String s1 = new String("jianghong");
String s3 = new String("jianghong");
String s2 = "jianghong";
String s4 = "jianghong";
那么s2=s4,s1!=s3.解释:new 出来的对象会调用String的构造函数,同时在堆里和对象池里各创建一个对象。但直接赋值会首先在对象池查找是否有相同的字符串,有的话则将地址指向这个字符。
例:
String a = "1";
String b = "2";
String c = "12";
String d = "1"+"2";
String e = a+b;
如果 final a final b 那么c和e‘是否相等
c = d ,c != e ,c=e'
解释:取决于在编译期间是否能知道它实际的内容。
6.数组:java.util.Arrays
排序:Arrays.sort(arr)
搜索:Arrays.binarySearch(arr,0,2,5);
冒泡排序、选择排序、反转排序(有序)
7.类
extends 继承与某个类
class SubClass extends SuperClass{
//构造方法调用父类构造方法
public Subclass(String name){
super (name)
}
}
implement 实现某个接口(interface支持被继承,类中支持多接口实现)
//定义了一个接口Flyer
interface Flyer
{
void fly ();
int ID = 1;
}
public class Animal extends Person implements Flyer,Runner{
@Override
public void fly() {
}
int j = Flyer.ID;
}
构造方法的调用顺序为先顶级再父类再自身
8.权限修饰符 java
| 包位置 |private|protected|public
| -------------|-------------| -----|
| 本类 |可见 | 不可见| 不可见 |
| 同包其他类或子类 |不可见 | 可见 | 可见 |
| 其它包的类或者子类 | 不可见 | 不可见 | 可见 |
类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),对于不是同一个包中的其他类相当于私有(private)。受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有
9.java内存回收(对象的销毁)当超出作用范围或者被赋为null的时候。不足之处为只能回收由new创建的对象,那么就要写方法finalize(),调用这个方法,手动将对象销毁(null)。但是当Java内存爆炸用完的时候
10.关于计算机编码基础
原码:
如果机器字长为n,那么一个数的原码就是用一个n位的二进制数,其中最高位为符号位:正数为0,负数为1。剩下的n-1位表示概数的绝对值。
例如: X=+101011 , [X]原= 00101011 X=-101011 , [X]原= 10101011
位数不够的用0补全。
PS:正数的原、反、补码都一样:0的原码跟反码都有两个,因为这里0被分为+0和-0。
反码:
反码就是在原码的基础上,符号位不变其他位按位取反(就是0变1,1变0)就可以了。
例如:X=-101011 , [X]原= 10101011 ,[X]反=11010100
补码:
补码也非常的简单就是在反码的基础上按照正常的加法运算加1。
例如:X=-101011 , [X]原= 10101011 ,[X]反=11010100,[X]补=11010101
PS:0的补码是唯一的,如果机器字长为8那么[0]补=00000000。
移码:
移码最简单了,不管正负数,只要将其补码的符号位取反即可。
例如:X=-101011 , [X]原= 10101011 ,[X]反=11010100,[X]补=11010101,[X]移=01010101
11.对象类型转型
向上转型:SuperClass super = new SubClass();即,将子类的对象赋值给父类。
例:假设SuperClass有个方法test(SuperClass class),这样如果根据子类对象的不同在父类的方法中,进行不同的处理,这就是多态的思想。
向下转型:将父类对象赋值给子类,可能会出现对象成员的错误,需要使用显示类型转换(SuperClass)
instanceof:判断某个对象是否为某一个类的一个实例
12.抽象类:使用abstract修饰,抽象类不能拥有实例化的对象,但可以通过继承和多态实现方法。抽象方法本身没有方法体,没有实际意义
13.java 中使用import可以指定某个包中的所有类,如:import com.test.jianghong.*,import不仅能导入类,也可以导入静态成员,如import:static java.lang.Math.max;
14.集合类 map、list、set
迭代器iterator(),
Collection<String> list =new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
Iterator <String> it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
```
15.I/O输入输出
所有输入流类都是抽象类InoutStream或Reader的子类。所有输出都是OutputStream或Writer的子类
InputStream是用来处理字节的,不适合处理字符文本(字符采用Unicode编码,双字节),而Reader则能处理字符流
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class StandardInputOutput {
public static void main(String args[]) {
String s;
// 创建缓冲区阅读器从键盘逐行读入数据
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(ir);
System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
+ "\nWindows系统: ctrl-z 退出");
try {
// 读一行数据,并标准输出至显示器
s = in.readLine();
// readLine()方法运行时若发生I/O错误,将抛出IOException异常
while (s != null) {
System.out.println("Read: " + s);
s = in.readLine();
}
// 关闭缓冲阅读器
in.close();
} catch (IOException e) { // Catch any IO exceptions.
e.printStackTrace();
}
}
}
16.class类与java的反射
通过getClass、getMethods等可以返回java对象的描述信息。如果去类名,类的构造方法,类中的成员等
17.Java中的枚举类enum,该类可定义枚举常量,也可以自定构造方法定义带参数的枚举类型成员
enum Constants2{
Constants_A("test1"),Constants_B("test2");
private String description;
private Constants2(String description){
this.description = description;
};
private String getDescription(){
return description;
}
}
public static void main (String []args ){
for (int i = 0; i <Constants2.values().length ; i++) {
out.println("枚举成员变量" + Constants2.values()[i]+"输入" + Constants2.values()[i].getDescription());
}
}
补充:枚举类也可以实现接口
interface d {
public String getDescription();
}
public enum Constant3 implements d{
Constants_A{
public String getDescription(){
return ("test3");
}
}
}
18.泛型类,使用格式为Class<T>,这个类不规定自身类型,在使用的时候自动转化为需要的类型
public class Tclass <T>{
private T[] array;
public void SetT(T[] array){
this.array = array;
}
public T[] getT(){
return array;
}
public static void main(String[] args) {
Tclass <String >tClass = new Tclass<String >();
String[] array = {"var1","var2","var3"};
tClass.SetT(array);
for (String a: tClass.getT()
) {
System.out.println("数组泛型类 "+a);
}
//通配符?先不确定类型,在实际使用的时候再确定类型
Tclass<? extends List> a = null;
a = new Tclass<ArrayList>();
a = new Tclass<LinkedList>();
}
}
网友评论