和Java相关的琐碎知识点

柔情只为你懂 2023-06-07 10:41 125阅读 0赞

和Java相关的琐碎知识点

本人是个新手，写下博客用于自我复习、自我总结。
如有错误之处，请各位大佬指出。

（1）标识符由字母、下划线、美元符号和数字组成，长度不受限制；
标识符第一个字符不能是数字；
关键字都是小写的。遇到大写的肯定不是关键字。

（2）若是float类型，就一定要加上f或F，否则这个数是double类型。

（3）数据类型精度：byte short char int long float double
若表达式中有double，则按double进行运算；
若表达式中最高精度为float，则按float进行运算；
若表达式中最高精度为long，则按long进行运算；
若表达式中精度低于int，则按int进行运算。

（4）逻辑运算符，也称短路运算符：&&，||

（5）位运算符：&（与），|（或），~（非） ，一定是左右两个整形数据。

（6）instanceof是一个二目运算符。其左面是对象，右面是类。
当左面是右面的类或子类创建的对象时，返回true，否则false。

（7）switch(表达式) 这个表达式值必须是byte,short,int,char

（8）成员变量：在整个类中都有效，在定义时有默认值。
局部变量：在方法体内定义的变量和方法的参数，只在方法内有效，无默认值。
类变量：加了static的变量
类方法：加了static的方法

（9）如果局部变量的名字与成员变量的名字相同，则成员变量在这个方法内暂时失效；
如果想在该方法中使用被隐藏的成员变量，必须使用关键字this；
局部变量只在方法内有效，而且从声明它的位置之后才开始有效。
声明成员变量时可同时赋初值，但在类体中不能有单独的赋值语句；
局部变量必须赋初值；
类方法只能调用该类的类方法；
类方法只能对类变量进行操作；
用类声明对象后，必须要创建对象。

（10）可变参数 public void f(int ...x)
这些参数类型相同，x也为最后一个参数；
...表示若干个参数，不给出具体名字和参数个数；
如同数组，会出现x[0],x[1]...x[m-1];
如可以输入f(1,2,3) ,f(3,4,6,8);
public void f(double a,int ...x)也可以。

（11）一个类可以把对象作为自己的成员变量，若用这样的类创建对象，那么该对象中
就会有其他对象。或者说该对象由几个对象组合而成。
即如果对象a组合了对象b，那么a就可用b中方法。

注：一个类声明的两个对象如果具有相同的引用，二者就具有完全相同的变量。

（12）实例成员与类成员的区别：
①所有对象共享类变量；
②通过类名可以直接访问类变量； （如：Lader.下底=100；）
③不同对象的实例变量互不相同。

（13）实例方法和类方法的区别：
①对象调用实例方法；
②类名可以直接调用类方法，类方法不可以操作实例变量。

（14）this可以出现在实例方法和构造方法中，但不可以出现在类方法中。

（15）类封装：Byte,Integer,Short,Long,Float,Double,Character
构造方法传入值，如：Double(double num) Float(float num)....
返回其中的值，如：doubleValue() floatValue()....

在Character中：
public static boolean isDigit(char ch) 判断它是不是数字
public static boolean isLetter(char ch) 判断它是不是字符

（16）对象数组：如：

  1. Student []stu;        //其中还都是空对象，因此在使用时，应当创建
  2. stu=new Student[10]; //数组所包含的对象,如：stu[0]=new Student();

（17）Java不支持多重继承，子类只能有一个父类。但一个类可以有多个或零个子类。

（18）Object是所有类的祖先类。

（19）子类与父类在同一包中，则继承的成员变量或方法的访问权限保持不变；子类与父类不在同一包中，则子类继承父类的Protected，Public成员变量或方法，且访问权限保持不变。

（20）①子类的构造方法总是先调用父类的构造方法，再调用子类自己的。
②若子类没有明确指定调用父类的某个构造方法，则会调用无参的构造方法。
③若父类没有无参的构造方法，则在子类构造方法中必须明确告诉调用父类的某个带参构造方法。
④调用父类的构造方法可以通过super关键字指定，且必须在第一句。
⑤子类在创建一个子类对象时，不仅子类中声明的成员变量被分配了内存，而且
父类的所有成员变量也都分配了内存空间。

（21）子类与父类成员变量同名时，父类的就被隐藏掉。同名的如果是方法，子类肯定是想重写这个方法，以实现自己的功能。那么重写就可以隐藏父类方法。

（22）重写不允许降低方法的访问权限，但可以提高。

（23）super关键字：
①用super可操作被隐藏的成员变量和方法
②用super可调用父类的构造方法，子类不会继承父类的构造方法。（肯定不能，
名称都不一样）

（24）final关键字：
①final可修饰类、成员变量和方法。代表常量。
②经final修饰的类、成员变量和方法不能被继承，当然也不能被重写。

（25）对象的上转型对象：
在这里插入图片描述

  1. A是B的父类。这个时候父类的对象是子类对象的上转型对象。
  2. ①上转型对象不能操作子类新增的成员变量和方法。即只能操作父类拥有的。
  3. ②若子类重写了父类的某实例方法，当用上转型对象调用这个实例方法时，一定会调用子类重写的这个实例方法。

（26）抽象类：
用abstract修饰的类称为抽象类，用abstract修饰的方法称为抽象方法。
①抽象类中可以有抽象方法，也可以没有。对于抽象方法只允许声明，不允许实现，而且不允许使用final修饰抽象方法。
②对于抽象类不能用new来创建该类的对象，只能产生其子类，由子类创建对象。这个子类一定要实现父类的所有抽象方法。当然，如果没有全部实现抽象方法，这个类必须定义成抽象类。
③抽象类封装了子类必须要有的行为标准，这个标准用抽象方法来表示。
④抽象类声明的对象可以成为其子类对象的上转型对象，调用子类重写的方法，即体现子类根据抽象类里的行为标准给出的具体行为。
⑤抽象方法不能在非抽象类里。
⑥抽象方法是非静态的，即抽象方法不能用static修饰。
⑦抽象类中也可以定义构造方法。
⑧即使子类的父类是具体的，这个子类也可以是抽象的。

（27）面向抽象编程：在设计程序时，可以先用抽象类，并在其中声明抽象方法，表明它在整个系统中的重要性，内容细节由其子类实现。

（28）熟练使用上转型对象以及面向抽象编程的思想，以便体现程序设计所提倡的开闭原则。即对扩展开放，对修改关闭。

（29）接口：
①Java不支持多重继承，接口能弥补这点，一个类可以实现多个接口。
②用interface定义接口，接口定义和类的定义相似，分为接口声明和接口体。
接口体中包含常量定义和方法定义，其中只进行方法声明，不允许提供方法实现。
如：

  1. interface Printable{ 
  2.     int MAX=100;
  3.     void add();
  4. }

注：接口中只允许出现常量，并且自动都是public static final，即可以不用详细定义，如上例。接口中的方法自动都是public abstract ，并且不能被static和final修饰，因为要重写接口中的方法，这与抽象类一样。
③接口没有构造函数，方法可以抛出异常。
④一个类用implements可声明自己实现的一个或者多个接口。
如：class A implements Printable,Addable{}
⑤如果一个类实现了某个接口，那也就意味着这个类必须重写该接口中的所有方法。
⑥接口可以通过继承产生新的接口。
⑦接口回调：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。这与上转型对象类似。
如：

  1. interface showMessage{ 
  2.             void show(String s);
  3.         }
  4.         class TV implements showMessage{ 
  5.             public void show(String s){ 
  6.                 System.out.println(s);
  7.             }
  8.         }
  9.         public class x{ 
  10.             public static void main(String args[]){ 
  11.                 showMessage sm;
  12.                 sm=new TV();
  13.                 sm.show("sss")
  14.             }
  15.         }

注：接口与抽象不同，实现接口的类中重写的方法前必须加public。
而继承抽象类的子类中的重写方法前可以不加public。
当然一个类可以继承抽象类，也可以实现接口。
如：class x extends y implements z{}
⑧使用接口进行程序设计（面向接口设计），主要就是用接口回调。
⑨接口参数：如果一个方法的参数是接口类型，我们就可以把任何实现该接口的类的实例的引用传递给接口参数。
如：

  1. interface SpeakHello{ 
  2.             void speakhello();
  3.         }
  4.         class C implements SpeakHello{ 
  5.             public void speakhello(){ 
  6.                 System.out.println("hello!")
  7.             }
  8.         }
  9.         class kindHello{ 
  10.             public void look(SpeakHello hello){ 
  11.                 hello.speakhello();
  12.             }
  13.         }
  14.         public class X{ 
  15.             public static void main(String args[]){ 
  16.                 kindHello kindhello=new kindHello();
  17.                 kindhello.look(new C());
  18.             }
  19.         }

（30）内部类

1.内部类
①Java支持在一个类中声明另一个类，这样的类称为内部类。
而包含内部类的类称为内部类的外嵌类（外部类）。
②内部类的类体中，不可以声明静态方法和变量。
③外部类的成员变量和方法在内部类中仍然有效。
但若是这个变量和方法重名了，可以用this区分。（可以名字相同）
这时内部类会默认访问自己的，若要访问外部类的同名方法，
用这个方法： 外部类名.this.方法或变量
④内部类都能独立地继承一个接口，无论外部类是否已经继承，
内部类是没有影响的。也就是说内部类和外部类相对独立。
⑤除了外部类，其他类无法访问内部类。
⑥外部类要先创建内部类对象，再利用内部类对象来访问内部类的
变量和方法
⑦内部类可以直接访问外部类的数据。

2.静态内部类：用static修饰的内部类。它与外部类同级，或叫做外部类的静态成员。它不能访问外部类的非static成员。

3.局部内部类：定义在代码块、方法体、作用域内的类。它可以用abstract修饰。无修饰符的局部内部类只能访问方法中定义的final类型的局部变量。

4.匿名内部类：（无类名）
①只能使用一次，创建实例之后，类定义立即消失。
②必须继承一个类（抽象、非抽象都可以）或者实现一个接口。
当然若父类是抽象类或者实现了一个接口，那么匿名内部类显然
需要实现其中的抽象方法。
③匿名内部类不能是个抽象类，因为它在定义之后，是需要创建一个实例的。
④它不能定义构造方法，但可以拥有与父类相同的所有构造方法。
⑤可以定义代码块，用于实例初始化，但不能定义静态代码块。
⑥可以定义新的方法和属性（不能用static修饰），但是无法显式调用，
因为使用new创建的量是“上转型对象”
⑦它是局部内部类，所以要符合局部内部类的要求。

（31）匿名类：Java允许我们直接使用一个类的子类的类体创建一个子类对象。
比如：

  1. board.showMess(new OutputAlphabet(){ 
  2.         public void output(){ 
  3.             （代码部分）
  4.         }
  5. }

也就是说，直接在调用这个方法的时候，对这个类进行定义。当然所谓的这个类也可以是实现了的接口。

（32）异常类：程序运行出现异常的时候，Java运行环境就会用异常类Exception的相应子类创建一个异常对象，并等待处理。当然我们可以继承这个异常类Exception，来实现我们自己设置的错误信息。

（33）断言：用于调试代码阶段。
如：assert number>0 :"负数不能是成绩";

（34）String类：
①String类在java.lang包中，默认引入这个包。
②java把String类声明为final，即不可重写。
③用户无法输出String对象的引用，输出的都是对象实体。
④构造字符串对象的方法：

  1. String s=new String("We are students");
  2. String s1="We are students";
  3. //这两种方法是不一样的。

如果：

  1. String s1,s2;  //String常量
  2. s1="你好";
  3. s2="你好";

那么s1和s2具有相同的引用。

⑤String类常见的构造方法：
(char数组 -> String)

  1. String(char a[]);  //用一个字符数组a创建一个String对象
  2. String(char a[],int startIndex,int count);
  3. //提取a中的一部分字符创建一个String对象。
  4. //参数startIndex：起始位置 count：截取字符个数。

(byte数组 -> String)

  1. String(byte a[]);  //用byte数组a创建一个String对象
  2. String(byte a[],int startIndex,int count);
  3. //提取a中的一部分字节创建一个String对象。
  4. //参数startIndex：起始位置 count：截取字符个数。
  5. //一个英文一个字节，一个中文两个字节

⑥常用方法：
1.public int length();
2.public boolean equals(String s);
3.public boolean startsWith(String s);
public boolean endsWith(String s); //判断字符前（后）缀是否是指定序列s
4.public int compareTo(String s); //按字典顺序与s字符序列比较大小
public int compareToIgnoreCase(String s); //不区分大小写的比较
5.public boolean contains(String s);//判断当前字符序列是否包含参数s的字符序列
6.public int indexOf(String s);//从0索引位置开始检索，记录第一次出现s序列的位置
public int indexOf(String s,int startpoint);//从指定起始点位置开始探索，记录第一次出现s序列的位置
7.public String substring(int startpoint); //从指定起始点位置开始，复制s字符序列，给当前字符
8.public String trim();//当前字符串去掉前后空格

⑦字符串与基本数据的相互转化

比如:(String -> 基本数据类型)

  1. int x;
  2. String s="876";
  3. x=Integer.parseInt(s);
  4. //类似地，Byte.....Double类也可以调用相应类方法，就可以转化

比如:(基本数据类型 -> String)

  1. String str=String.valueof(12313.9876);
  2. //类似地，所有基本数据类型都可以转化为String

部分代码：

  1. double sum=0,item=0;
  2.     for(String s:args){  //一种输入方法
  3.         try{ 
  4.             item=Double.parseDouble(s);
  5.             sum=sum+item;
  6.         }catch(NumberFormatException e){ 
  7.             .....
  8.             //如果输入类型有错则输出自定义的错误信息
  9.         }
  10.     }

⑧对象的字符串表示
Object类有一个public String toString()方法
通过该方法可以获得该对象的字符序列。
返回的字符序列格式：
创建对象的类的名字@对象的引用的字符串表示
如：

  1. public String toString(){ 
  2.     String x=super.toString();
  3.     return x+"...//某些信息";
  4. }

⑨字符串与字符、字节数组
(String -> char数组)
1.public void getChars(int start,int end,char c[],int offset)//将String对象的字符序列从start到end-1存放到数组c的offset处
2.public char[] toCharArray()//将String对象变成char数组，返回到一个已经存在的char数组中
上述两种方法的区别在于，一个没有返回，一个有返回。
比如：

  1. char []a,c;
  2.       a=new char[4];
  3.       String s="信息信息信息";
  4.       s.getChars(1,5,a,0);
  5.        //或：
  6.        c="信息信息信息".toCharArray();

(String -> byte数组)
1.public byte[] getBytes();
2.public byte[] getBytes(String charsetName);
//使用指定字节编码的转化
//注意区分与char转化的区别

比如：byte d[]="你好".getBytes();

⑩例：字符串加密算法

  1. String 加密(String password,String SourceString){ 
  2.         //password输入密码 SourceString文件内容
  3.         char []p=password.toCharArray();
  4.         int n=p.length;
  5.         char []c=SourceString.toCharArray();
  6.         int m=c.length;
  7.         for(int k=0;k<=m;k++){ 
  8.             int mima=c[k]+p[k%n];
  9.             c[k]=(char)mima;
  10.         }
  11.         return new String(c);
  12.     }
  13.     String 解密(String password,String SourceString){ 
  14.         //password输入密码 SourceString文件内容
  15.         char []p=password.toCharArray();
  16.         int n=p.length;
  17.         char []c=SourceString.toCharArray();
  18.         int m=c.length;
  19.         for(int k=0;k<=m;k++){ 
  20.             int mima=c[k]-p[k%n];
  21.             c[k]=(char)mima;
  22.         }
  23.         return new String(c);
  24.     }

⑩①正则表达式及字符串的替换与分解
1.public boolean matches(String regex); //判断当前String对象的字符序列是否和参数regex指定的正则表达式匹配

正则表达式是具有特殊意义的元字符，比如\\dcat中的\\d，
这个也是正则表达式的类似写法。\\d的意思是0-9中的任意一个数字。

比如：

  1. String regax="[159ABC]";
  2.              String str="测试信息";
  3.              if(str.matches(regex)){ 
  4.                  //如果匹配成功则输出相关信息
  5.              }

那么在这里的意思就是，“1ABC”“5ABC””9ABC”三个才能匹配。

  1. public String replaceAll(String regex,String replacement);
    //满足正则表达式regex的，都用replacement代替.

比如：String s="12hello567bird".replaceAll("[a-zA-Z]+","你好");
//也就是说只要出现字母（大小写）全部都替换为”你好”
//输出结果就是”12你好567你好”

  1. public String[] split(String regex);
    //使用正则表达式regex作为分隔标记，并将分解出的单词放在数组中

比如：

  1. String str="1949年10月1日";
  2. String regex="\\D+"; //非数组字符串作为分隔标记
  3. String digitWord[]=str.split(regex);

那么digitWord[0],digitWord[1],digitWord[2]分别是”1949””10”“1”

注意：如果String字符序列的前缀和regex匹配，比如”公元1949年10月1日”因为split会把符合分隔标记的左侧的东西记录下来。所以这里会存储4个值，而不是上例的3个。其中一个是””

(35)StringTokenizer类 （在java.util包中）
①常用构造方法
1.StringTokenizer(String s);
//为s构造一个分析器，使用默认的分隔标记，如空格、换行、tab、回车
2.StringTokenizer(String s,String delim);
//为s构造一个分析器，给定分隔标记

如：StringTokenizer fenxi=new Stringtokenizer("you//*are//welcome","#*");

②方法
1.nextToken();
//逐个获取字符串中的语言符号
2.hasMoreTokens();
//判断字符串是否还有语言符号
3.countTokens();
//返回字符串中语言符号的个数

(36)Scanner类：从字符串解析数据
如：

  1. String NBA="I love game";
  2. Scanner scanner=new Scanner(NBA);

①方法
useDelimiter(正则表达式）;
//与正则表达式匹配的字符序列作为分隔标记
②scanner调用next()可依次返回NBA中的单词
hasNext()判断之后还有没有单词
③若解析数字型单词，可用nextInt()或nextDouble()来代替next()方法

  1. 如：
  3. String regex="[^0123456789.]+";
  4.     Scanner scanner=new Scanner(cost);
  5.     scanner.useDelimiter(regex);

注意：从目前来看StringTokenizer和Scanner类完成的是一样的功能，即给定一个分隔标记去获得自己想要的东西。但是StringTokenizer解析出来的都放到StringTokenizer对象中，这样程序会更快，但会占据更多的内存，所以建议负责小数据，用Scanner负责长数据.

(37)StringBuffer类
String对象的字符序列的字符是不可以被修改、删除的。
StringBuffer类的对象的实体的内存空间可以自动地改变大小，便于
存放一个可变化的字符序列。
①常用方法：

  1. StringBuffer append(String s);  //将s追加到当前对象中
  2.         StringBuffer append(int n);  //将int型数据转为String再追加到当前对象中
  3.         StringBuffer append(object o);  //其他类型同理
  5.         public char charAt(int n);  //得到参数n指定位置上的单个字符
  6.         public void setCharAt(int n,char ch);  //将对应位置上的字符用ch替代
  8.         StringBuffer insert(int index,String str);  //在指定位置上插入相应字符
  10.         public StringBuffer reverse();  //翻转字符
  12.         StringBuffer delete(int startIndex,int endIndex); //删除指定区域的子字符串
  13.         StringBuffer deleteCharAt(int index); //删除指定位置的一个字符
  15.         StringBuffer replace(int startIndex,int endIndex,String str); //将指定区域的子字符串用str替代

比如：

  1. StringBuffer str=new StringBuffer();
  2.          str.append("你好");
  3.          System.out.println(str.length);
  4.          System.out.println(str.capacity);
  5.          str.setCharAt(0,'we');
  6.          str.insert(2,'are');
  7.          int index=1;
  8.          str.replace(index,str.length,"你好");

(38)Math、BigInteger、Random类
Math在java.lang包中，BigInteger在java.math包中
Math包含进行科学计算的类方法（方法太多，百度查找）
BigInteger提供任意精度的整数运算（方法太多，百度查找）

Random类例：

  1. Random random=new Random();
  2. random.nextInt(100); //返回一个从0到100间的随机整数，包含0不包含100
  3. //或者random.nextBoolean();
  4. //其他类型类似

(39)Console类：输入文本，但不在命令行显式
在java.io包中

  1. 比如：
  3. Console cons=System.console();
  4.  char[] pw=cons.readPassword();
  5.  String password=new String(pw);
  6.  if(password.equals("密码")){ 
  7.      //输出密码正确相关信息
  8.  }

(40)Pattern与Matcher类：进行模式匹配
在java.util.regex包

比如：

  1. String regex="good";
  2.  Pattern p=Pattern.compile(regex);
  3.  String input="Hello,good morning";
  4.  Matcher m=p.m(input);

方法：

  1. public boolean find();      //是否有下一个和regex匹配的子序列
  2. public boolean matches():   //是否完全匹配
  3. public boolean lookingAt(): //是否有和regex匹配的子序列

发表评论

表情：
评论列表 （有 0 条评论，125人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java的一些琐碎的基础知识01

    第一章 1.所有的编程语言的最终目的都是提供一种“抽象”方法。抽象的层次越高，越接近人的思维。越接近人的思维，越容易使用。 2.越高级的语言越容易学习；当然，这只意味着容易

    小灰灰小灰灰/ 0 赞/ 145 阅读