int arr = new int[3];
int[] arr1 = new int[3];
int[] arr2 = arr1;
int[] arr = {1,2,3};
arr.length();
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
public class 类名 {
成员变量;
成员方法(){
方法;
}
}
类似于c++的结构体
类名 对象名 = new 类名();
private
关键字与get/set
方法A/t + Insert
能自动填充public class Num {
private int num;
public void setNum(int i){
num = i;
}
public int getNum(){
return num;
}
}
this
关键字用于区分局部变量和成员变量
public class 类名 {
private int num;
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
当给出构造方法之后,系统将不再提供默认的无参构造方法
public class 类名 {
private int num;
private String name;
public 类名() {}
public 类名(int num) {
this.num = num;
}
public 类名(String name) {
this.name = name;
}
public show(){
//用于显示对象信息
}
}
类名 c1 = new 类名(123);
类名 c2 = new 类名(“wmh”);
public String(...);
String str = "wmh";
equals
//定义
public boolean quuals(Object anObj);
//使用
boolean b = str1.equals(str2);
length
//定义
public int length();
//使用
int strlen = str.length();
startsWith
//定义
boolean startsWith(Name n)
charAT
//定义
public char charAT(int index);
//使用
char c = str.charAT(2);
public StringBuilder();
public StirngBuilder(String s);
append
//定义
public StringBuilder append(任意类型);
//使用
sb.append("wmh");
//链式编程
sb.append("wmh").append("is").append(666);
reverse
//定义
public StirngBuilder reverse();
//使用
sb.reverse();
toString
//定义
public String toString();
//使用
String str = sb.toString();
//定义
public StringBuilder(String str);
//使用
StringBuilder sb = new StringBuilder(str);
ArrayList<范型>
//定义
public ArrayList();
//使用
ArrayList<String> array = new ArrayList<String>();
add
//定义
public boolean add(E e);
//使用
array.add("wmh");
add
//定义
public void add(int index, E e);
//使用
array.add(0, "wmh"); //注意索引的越界访问
remove
//定义
public boolean remove(Object obj);
public E remove(int index);
//使用
array.remove("wmh");
array.remove(0);
set
//定义
public E set(int index, E e);
//使用
array.set(0,"wmh"); //注意索引的越界访问
get
//定义
public E get(int index);
//使用
String str = array.get(0);
size
//定义
public int size();
//使用
int len = array.size();
public class 子类名 extend 父类名{}
super.成员变量
super(...)
super.成员方法()
i
-> 子类成员变量this.i
-> 父类成员变量super.i
super();
@Override
--> 用于检查重写声明的正确性package 包名; //多级包用.分割
修饰符 | 同类 | 同包异类 | 异包子类 | 异包异类 |
---|---|---|---|---|
Private | √ | |||
默认 | √ | √ | ||
Protected | √ | √ | √ | |
Public | √ | √ | √ | √ |
成员变量:编译看左边,运行看左边
成员方法:编译看左边,运行看右边
原因:成员方法有重写,而成员变量没有
好处:提高了程序的拓展性
弊端:不能使用子类的特有功能
向上转型:由子到父,父类引用指向子类对象:Animal a = new Cat();
向下转型:由父到子,父类引用转为子类对象:Cat c = (Cat) a;
必须用abstract关键字修饰
public abstract class ClassName {}
public abstract void MethodName();
抽象类多态:抽象类参照多态的方式,通过子类对象实例化
抽象类的子类
重写抽象方法
定义抽象类
接口是一个公用的规范标准,更多的体现在对行为的抽象
public interface 接口名{}
public class implements 接口名{}
类名–>对象(就像:数据类型–>变量)
抽象类–>子类对象
概述:类里面定义一个类
格式
public class 类名{
修饰符 class 类名{
}
}
访问特点
内部类的位置
成员内部类创建对象方法
外部类.内部类 对象名 = 外部类对象.内部类对象;
Outer.Inner Oi = new Outer().new Inner();
public void method() {
class Inner(){
}
}
// 第一种
new 类名或者接口名(){
重写方法;
}.方法();
// 第二种
类名或者接口名 对象 = new 类名或者接口名(){
重写方法;
};