文 章 目 录 |
类型转换
int a=(int)'a';
char b=(char)97;
a.getClass()
--查看类型
常量
static final float pi=3.14159f;
final int one=1;
逻辑运算
与
&
或
|
非
~
移位
<<
>>
无符号右移
>>>
三元运算符
int a=12>20?1:0;
# python
a = 1 if 12>20 else 0
复合语句
public static void min(String[] args){
int a=12;
for(int i=0;i<a:i++){
System.out.println("hello world");
{
// 定义的变量只在花括号内有意义
int b=13;
int c=0;
a--;
{
char a='a';
String s="Hello world";
}
}
}
System.out.println("Over");
}
流程控制
判断
if(a>12){
b=12;
}
else if(a<=12&&a>0){
b=11;
}
else{
b=0
}
for循环
for(int i=0;i<12;i++){
a += i;
}
else{ //跟Python用法差不多
// 循环正常结束则执行 else
System.out.println("Over");
}
for each
for(int a[]:arr2){
for(int b:a){
System.out.println(b);
}
}
switch分支
int a=12;
switch (a){
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("not 1 2 3");
}
while
int c = 0;
int a = 12;
while(a>0){
int b=2;
c += 2;
c = c<<1;
a--;
}
do while
int a = 4;
int c = 2;
do{
c += 12;
c = c>>>1;
a--;
}while(a>0);
Break 循环体
标签0:循环体{
标签1:循环体{
...
....
break 标签0;
...
}
}
loop1: while(a<b){
a++;
loop2: for(int i=12;i>1;i--){
c += i;
if(c>12){
break loop1;
}
}
}
String
定义
String s = "hello wworld";
String s = new String("hello world");
char a[]={'h', 'e','l','l','o'}; String s = new String(a);
索引
str.charAt(int index);
定位
str.indexOf(substring);
str.lastindexOf(substring);
长度
str.length();
取子串
str.substring(begin[,end]);
去两头空格
str.trim()
替换
str.replace(old, new)
判断开头、结尾
str.endsWith(substring)
str.starsWith(substring)
判断相等
str1.equals(str2)
区分大小写
str2.equalsIgnoreCase(str2)
不区分
比较
str.compare(str2)
相等才返回0
小写
str.toLowerCase()
大写
str.toUpperCase()
切片
str.split(str1)
str1可以为正则表达式
字符串格式化
str.format()
正则
可以用,跟爬虫学的差不离
数组
定义
int a[] = {1,2,3};
int a[] = new int[]{1,2,3};
int a[][];
a = new int[2][];
a[1] = new int[2];
a[0] = new int[3];
填充
fill(arr, data);
fill(arr, from, to, data);
复制
arr2 = Arrays.copyOf(arr, length);
arr2 = Arrays.copyOfRange(arr, from, to);
查询
Arrays.binarySearch(arr, from, to, data);
排序
Arrays.sort(arr)
import java.util.Arrays
arr1 = Arrays.sort(arr);
public class Book{
private String name;
public String getName(){
int id=0;
setName("Java");
return id+this.name;
}
private void setName(String name){
this.name = name;
}
public Book getBook(){
return this;
}
}
权限修饰符
访问位置 ↓ | private | protected | public |
---|---|---|---|
本类 | 可见 | 可见 | 可见 |
同包其他类或子类 | 不可见 | 可见 | 可见 |
其他包的类或子类 | 不可见 | 不可见 | 可见 |
!类的权限设定会约束类成员的权限
package test
class AnyClass{
public void doString(){
//方法主体
...
}
}
上述等同于下面代码
[由于类的修饰符为默认修饰符]
package test
class AnyClass{
void doString(){
//方法主体
....
}
}
this
关键字用于代表本类对象的引用。
类的构造方法
- 用于创建对象
- 与类同名
public class TestOne{
public TestOne(){ //无参构造方法
this("通过 this 调用有参的构造方法");
// 只可以在无参构造第一句用this 调用 有参构造
System.out.println("调用了无参构造方法。");
}
public TestOne(String name){
this.name = name;
System.out.pringln("调用了有参构造方法");
}
}
【示例】
public class hellojava {
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.print("hello world!");
System.out.print("hello java\n");
NoName n = new NoName(119, "wula", 23);
System.out.println("id: " + n.id);
n.Getprofile();
}
}
class NoName{
protected int id=0;
protected String name="";
public int price=0;
public NoName() {
this.id = 22;
this.name = "hello";
this.price = 34;
}
public NoName(int id, String name,int price) {
this.id = id;
this.name = name;
this.price = price;
}
public void Getprofile() {
System.out.println(this.id+this.name+this.price);
}
}
静态变量、常量、方法
- 静态方法中不可以使用this关键字
- 静态方法中不可以直接调用非静态方法
- 不能将方法体内的局部变量声明为static的
public class StaticTest{
final static double PI = 3.14159; //定义静态常量
static int id; //定义静态变量
public static void method1(){ //定义静态方法
//None
}
public void method2(){ //定义非静态方法
System.out.println(StaticTest.PI);
System.out.println(StaticTest.id);
StaticTest.method1();
}
public static StaticTest method3(){ //定义静态方法
//....
method2(); //调用非静态方法 [x]
return this; //使用this关键字 [x]
}
}
静态数据与方法的作用通常是为了提供共享数据或方法
- 可以用
static
定义一个静态区域(希望先执行类的初始化动作时) - 示例
- 执行此段代码时,static块中的代码先执行,且只会执行一次
public class example{
static{
//do somethind
}
}
类的主要方法
public class Test{
public static void main(String[] args){
for(int i=0;i<args.length();i++){
System.out.println(args[i]);
}
}
}
对象的创建与使用
public class Test{
int i = 12;
public void call(){
System.out.println("hello world");
for(i=0;i<10<i++){
System.out.print(i+" ");
if(i == 2){
System.out.println("ln");
}
}
}
public Test(){
}
public static void main(String[] args){
Test t1 = new Test();
Test t2 = new Test();
t2.i = 30;
System.out.println("对象t1的变量i值" + t1.i);
t1.call();
System.out.println("对象t2变量i值:" + t2.i);
t2.call();
}
}
对象的比较
==
比较两对象的引用地址是否相同str1.equals(str2)
比较两对象内容
String s1 = new String("abs");
String s2 = new String("abs");
String s3 = s1;
System.out.println("s2 == s3 ? :" + s2 == s3);
System.out.println("s2.equals(s3) ? :" + s2.equals(s3));
输出
>> s2 == s3 ? :false
>> s2.equals(s3) ? :true
对象的销毁
- 对象超过其作用范围
{//超过此花括号...
Test t = new Test();
}
- 对象被赋值
null
{
Test t = new Test();
t = null;
}
垃圾回收
Java提供了一个 finalize() 方法(Object类、声明为 protected)。 用户可以在自己的类里定义这个方法,于是垃圾回收时会首先调用该方法,在下一次垃圾回收动作发生时,才能真正回收被对象占用的内存。 |
强制启动垃圾回收器
System.gc()