java学习

最新推荐文章于 2022-04-30 21:37:28 发布

MoMo的奋斗

最新推荐文章于 2022-04-30 21:37:28 发布

阅读量576

点赞数 1

文章标签：语言

本文链接：https://blog.csdn.net/u012510204/article/details/52029329

版权

计算机语言

标签（空格分隔）： Java

计算机语言

1. Java语言基础

1. 基本数据类型

数据类型	占字节数	所占位数
boolean	1	8
byte	1	8
short	2	16
int	4	32
long	8	64
char	2	16
float	4	32
double	8	64

2. 优先级

类别	运算符	结合性
一元运算符	`++` `--` `+` `-` `!` `~` `(type)`	从右向左
算数运算符	`*` `/` `%` `+` `-`	从左向右
移位运算符	`<<` `>>` `>>>`	从左向右
关系运算符	`<` `<=` `>` `>=` `instanceof` `==` `!=`	从左到右
位运算符	`&` `^` `或`	从左向右
逻辑运算符	`&&` `或`	从左到右
条件运算符	`? :`	从左到右
赋值运算符	`=` `op=`	从右向左

goto和const尽管是两个关键字，但是没有使用。
类名和接口名一般首字母大写，若为多个单词则每个单词首字母大写
该语言中没有 sizeof运算符，所有的数据类型长度和表示是固定的
变量名和方法名一般用小写字母，入围多个单词，从第二个开始首字母大写
final修饰的变量一旦为其赋值，就不能改变
对于long型数据可以在后面加上l或者L
Java中的布尔型数据不能与数值数据相互转换
按位无符号右移>>>
异或操作 0 1 1 0
数据类型的转换可以从低到高，long可以转成float, double
除了赋值要发生类型转换外，在含有变量的表达式中也有类似类型转换的问题

byte a = 40;
byte b = 50;
byte c = a+b;  //编译错误
byte c = (byte)(a+b);
int i = a+b;

3. 类

abstract修饰符声明抽象类
final修饰类为最终类，不能被继承
类名以大写字母开头
extends指明该类的超类SusperClass为超类名
Object为Java的根类，
java只支持单继成
implements InterfaceNameList用来定义该类实现了那些接口，若实现多个接口，接口命中要用逗号分开
成员变量的修饰
1.public protect private
2.static
3.final修饰为最终变量，也称为标识符常量一旦赋值就不能改变
4.transient修饰变量为临时变量
5.volatile修饰变量为共享变量。
成员方法的修饰
1.public private protected
1. static ,修饰的方法称为实例方法
2. final，最终方法不能被覆盖，
3. abstract，抽象方法
4. synchronized，修饰的方法称为同步方法
5. native，成为本地方法，本地方法用来调用其他语言编写的函数
6. throws，用于异常

2. 涉及英语单词

operator: 运算符
operand : 操作数
expression: 表达式
Inner Class : 内部类
Nested Class : 嵌套类
Outer Class : 外部类
Enclosing Class : 外围类
Autoboxing : 自动装箱
Unboxing : 自动拆箱
Quantifiers 量词
Greedy 贪婪量词
Reluctant 勉强量词
Possessive 具有量词
exception 异常

3.补充

增强型for循环

int b[] = {1, 2, 3};
for (int a : b)
    System.out.println(a);

int a[][] = new int[2][3];
for (int i[]: a) {  //或者for (int[] i: a) {
    for (int y: i)
        System.out.print(y);
     System.out.println();
}

数组元素的复制

int []a = {1, 2, 3};
int []b = new int[a.length];
System.arraycopy(a, 0, b, 0, 3);

可变参数的方法，可变参数必须是方法的最后一个参数。
数组的排序
- java.util.sort(a);
在java语言中，对多维数组非配存储空间时，首先为最高维分配存储空间，然后为低维分配存储空间
String 是不变字符串，StringBuilder类和StringBuffer类是可变字符串

字符串处理

字符船厂量存储和对象存储不同，字符串常量是存储在常量池中，对内容相同的字符串常量在常量池中只有一个副本。对于

String a = "hello";
String b = "hello";

a和 b 指向同一个地方。

字符串不能用>, >=, <, <=进行比较，但可以使用！=比较

String不同于C++中的string，不能对一个String 对象使用[]

public String concat(String str) ：连接字符串
public String substring (int beginIndex) ：子串
public String replace (char oldChar, char newChar) ：字符替换
public String toUpperCase() ：换大写
public String toLowerCase() ：换小写
public boolean startsWith(String prefix): 是否以某个字符串开始
public boolean endsWith(String suffix) ：是否以某个字符串结束
public String trim() ：去掉前后空白字符的字符串对象

字符串查找

public int indexOf(int ch) ：查找第一次出现的位置，否则-1
public int indexOf(int ch, int fromIndex): 同上
public int lastIndexOf(int ch) ：查找字符ch最后出现的位置
public int lastIndexOf(int ch, int endIndex) ：到endIndex为止最后出现的位置
public int indexOf(String str) : 第一次出现的地方
public int indexOf(String str, int fromIndex)
public int lastIndexOf(String str)
public int lastIndexOf(String str, int endIndex)

字符串与数组的转换

public char[] toCharArray() ：将字符串转为字符数组
public byte[] getBytes()
public byte[] getBytes(String charsetName) : 使用指定字符集
public void getChars(int srcBegin, int srcEnd, char[]dst, int dstBegin)

String类提供了一个split()方法，用于实现讲一个字符串分解成子字符串或令牌(Token)的功能。该方法使用正则表达式指定分隔符。

public String[] split(String regex, int n)
1. regex是正则表达式
2. n表示模式应用的次数，
  - 等于0，将应用尽可能多的次数，末尾的空字符串被丢弃。
  - 大于0，则至多被应用n-1次,最后一项将包含除最后一个匹配的分隔符外的所有输入内容。
  - 小于0，将应用尽可能多的次数。
public String[] split(String regex) ，与上面 n=0 情况相同
字符串大小比较
1. ==,返回值为true,flase
2. equals(String )
3. public int compareTo(String antotherString)
如果要忽略大小写
1. public boolean equalsIgnoreCase(String anotherString)
2. public int compareToIgnoreCase(String anotherString)
比较两个字符串特定区域的字符串是否相等
1. public boolean regionMatches(int toffset, String other, int offset, int len)
2. public boolean regionMathches(boolean ignoreCase, int toffset, String other, int offset, int len)
java中，一旦创建了一个String对象，就不能对其内容进行修改，String对象是不可标的字符串，有些方法看起来是修改字符串但是其实是创建了一个新的字符串;
StringBuilder类
1. public StringBuilder()创建一个没有字符的缓冲区，大小为16个字符，此时length()值为0， capacity()大小为16
2. public String Builder(int capacity)
3. public String Builder(String str)，创建字符缓冲区对象，另外再分配16个字符的缓冲区
访问方法
1. capacity(): 返回总容量
2. setCharAt(int index, char ch): 修改指定位置字符
3. append(String str): 在当前的字符串的末尾添加一个由str指定的字符串，参数可以为boolean, char, int , long , float, double, char[]等任何数据类型
4. public StringBuilder delete(int start,int end): 删除从start开始到end之间的字符。
5. public StringBuilder replace(int start, int end, String str) : 代替
6. public String substring(int start)
7. public String substring(int start, int end)
8. void setLength(int newLength): 小于原长度会被截短

Object 类（java.lang.Object）

Object 类里面总共定义了11个方法（3个重载方法），
1. public boolean equals(Object obj)
2. public String toString()
3. public int hashCode() 返回对象的散列码值（对象在计算机内部存储的十进制内存地址）
final修饰变量，表示该变量为常量
1. 对类的成员变量，常使用static与final组合使用，称为编译时常量，编译器可以将该变量只带入任何可能使用到该常量的地方，减轻运行时的负担。
final修饰方法，则该方法不能被子类覆盖
final修饰类，则该类不能被继承
Java中通过包和类或类的成员的访问权限实现封装型
访问权限

修饰符	同一个类	同一个包的类	不同包的子类	任何类
private	y
缺省	y	y
protected	y	y	y
public	y	y	y	y

由于类的继承性，子类对象和超类对象的相互转换称为对象转换或造型（Casting）
为了保证超类对象正确的额转为子类对象，可以在转换前使用instanceof运算符来检验类型
1. $variable$ instanceof $TypeName$ : 如果variable是TypeName类型的实例，则返回true
动态绑定：将一个方法调用同一个方法主体关联起来
前期绑定：在执行程序前进行绑定
后期（动态）绑定：在程序运行时根据对象的类型进行绑定
Java中除了static方法和final方法外都是后期绑定

抽象方法，与抽象类，关键字abstract

包含抽象方法的类应该定义为抽象类，
抽象类中可以使用构造方法，抽象方法不需要实现，抽象类不能被实例化
抽象类的子类还是抽象类，只有非抽象的子类才能使用new创建对象
抽象类中可以没有抽象方法，但仍需被继承才能实例化
final和abstract不能在定义类时同时使用

接口（Interface）是常量和方法的集合，这些方法只有声明没有实现

常规内部类，没有用static修饰，且定义在外部类的类体中

在内部类中既可以访问该类本身定义的变量和外部变量，也可以访问外部类的方法，这些实例方法可以是任何权限。
在内部类中不能定义static变量和static 方法
内部类可以使用abstract和final修饰，其含义与其他类一样
内部类可以使用private, public, protected, 或者包可访问修饰符

public class Test {
    public static void main(String []argv) {
        MyOuter mo = new MyOuter();
        MyOuter.MyInner in = mo.new MyInner(); //通过创建的外部类对象创建内部类
        in.innerMethod();
    }
}

class MyOuter {
    private int x = 100;
    public class MyInner {
        private String y = "hello";
        public void innerMethod() {
            System.out.println("y = "+y);
            System.out.println("x = "+x);   //直接访问外部类成员
            outerMethod();
            System.out.println("x = "+MyOuter.this.x);  //使用外部类名访问外部类成员
        }
    }
    public void outerMethod() {
        x++;
    }
    public void makeInner() {
        MyInner anInner = this.new MyInner();
    }
}

静态内部类：用static修饰的内部类，只能访问外部类的static成员，不能直接访问外部类的实例变量和实例方法，只有通过对象访问才能访问。不具有外部类的引用。

public class Test {
    public static void main(String []argv) {
        MyOuter.MyInner anInner = new MyOuter.MyInner();  //和常规内部类不同，不通过外部类实例就可以创建对象，
        anInner.innerMethod();

    }
}

class MyOuter {
    private static int x = 100;
    public static class MyInner {
        private String y = "hello";
        public void innerMethod() {
            System.out.println("y = "+y);
            System.out.println("x = "+x);
        }
    }
}

内部接口隐含属性是static的。

枚举类型

枚举类型内最后一个常量后面的分号不能省略

ennum WeekDay {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY; //不能省略
}
public class Test {
public static void main(String argv[]) {
WeekDay rest = WeekDay.SUNDAY;
System.out.prinln(rest);
}
}
每个枚举类型E都有连个静态方法，
1. public static E[] values(); 返回一个包含了所有枚举常量的数组
2. public static E valueOf(String name); 返回指定名字的枚举常量。
任何枚举类型都隐含的继承了java.lang.Enum抽象类
每个枚举类型都包含了若干方法
1. public final int compareTo(E o); 返回比较结果
2. public final class getDeclaringClass(); 返回对应该枚举常量的枚举类型的类对象。假设有两个枚举常量a, b。当且仅当a.getDeclaringClass() == b.getDeclaringClass()时，两个枚举常量类型才相同。
3. public final String name(): 返回枚举常量名
4. public final int ording() ；返回枚举常量的顺序值，第一个常量顺序值为0
枚举类型还可以声明构造方法，成员变量，和其他方法。

public class Test {
    enum Meal {
        BREAKFAST(7, 20), LUNCH(12, 15), DINNER(6, 30);

        private int hh;
        private int mm;
        Meal(int hh, int mm) {
            assert(hh >= 0 && hh <= 23) : "小时范围非法";
            assert(mm >= 0 && mm <= 59) : "分钟范围非法";
            this.hh = hh;
            this.mm = mm;
        }
        public int hour() {
            return hh;
        }
        public int mins() {
            return mm;
        }
    }
    public static void main(String []argv) {
        Meal bf = Meal.BREAKFAST;
        System.out.println("早饭时间： "+bf.hour()+": "+bf.mins());
    }
}

注解类型，关键字interface,前面加上@

注解类型中声明的方法称为元素，没有方法体，但又返回类型，元素的类型只能是基本类型，String，枚举类型，其他注解类型等。并且元素不能声明任何参数。
在定义注解时可以使用default为元素指定默认值
当注解类中没有元素时，称为标记注解
如果只有一个元素，这个元素应该命名为value，
注解程序元素时，使用@符号家注解类型名

public @interface Version {
    int major() default 1;
    int minor() default 0;
}
public @interface classInfo {
    String created();
    String author();
    String lastModified();
    Version version();
}
@classInfor (
    created = "Jan 31 3010",
    author = "Zhao Pengtao",
    lastModified = "Nov 30 2010",
    version = 3
)

初始化顺序不重要，但每个元素只能出现一次。如果有默认值可以不初始化
在java.lang包中，@Deprecated, @Override, @SuppressWarnings,为Java语言规范中定义的。
在java.lang.annotation包中，@Documented, @INherited, @Retention, Target.

java类库

java.lang
1. 主要有Object类，Math类，数据类型包类， String类， StrinBuilder类，Thread类， Exception类等
2. 还有一些接口CharSequence接口， Cloneable接口， Comparable接口， Runnable接口
java.applet
1. 只有一个Applet类，是Java小程序的根类，是JApplet类的父类
java.awt
1. 包含了与创建图形用户界面的应用有关的类，如：Button, Label
2. 一些辅助类Color, Font , LayoutManager类等
java.awt.event
1. 包含了有关事件处理的类和接口，如： ActionEvent, MouseEvent, WindowEvent, WindowEvent, KeyEvent等
2. 接口： ActionListener, MouseListener, MouseMotionListener, WindowListener, KeyListener等
javax.swing
1. 定义了大量的创建图形用户界面的类，如： JApplet, JButton, JLabel , JCheckBox, JFrame, JPanel, JMenu类等。
java.io
1. 定义了有关输入输出的类，InputStream, OutputStream, BufferedReader, BufferedWriter, File, RandomAccessFile类
java.net
1. 定义了与网络编程有关的类, 如： URL, Socket, ServerSocket类等。
java.sql和javax.sql
1. 定义了有关数据库编程的类，称为JDBC API。
java.text
1. 定义了有关文本格式化的类,如： DataFormat, NumberFormat
java.util
1. 定义了一些工具类， Data, Calendar, Scanner, Locale
2. 有关数据结构和对象集合类, Collection , List, Set, ArrayList, Stack, Hashtable, Vector, Enumeration类等
java.util.regex
1. 定义了有关模式匹配的类,如： Pattern， Matcher类等