int i=10;
String s="100";
int i1 = Integer.parseInt(s);//核心
String s1 = String.valueOf(i);//核心
生成随机数
import java.util.Random; Random random=new Random(); int number=random.nextInt(x); //number 的范围是 [0,x)整数
- 格式化:Ctrl Alt l
int[] arr=new int[3]; arr=null; System.out.print(arr[0]); //NullPointerException方法不能嵌套定义 判断方法重载的条件
- 主要看 函数名 和 函数的形参
- *但是，假如两个方法函数名和函数形参都符合，但是不在同一个类中，也不构成方法重载
//不死神兔:有一对兔子，从出生后第三个月起每个月生一对兔子，小兔子长到第三个月后每个月也会生一对兔子假设兔子都不会死,求第20个月后，兔子的对数是多少
// 1 1 2 3 5 ......从三个数起，每个数为前两个数之和
public class MainApplication {
public static void main(String[] args) {
int[] arr=new int[20];
arr[0]=1;
arr[1]=1;
for (int i = 2; i < arr.length; i++) {
arr[i]=arr[i-2]+arr[i-1];
}
System.out.println("第19天的总兔子对数为"+arr[19]);
}
}
String 类在java.lang包下，使用的时候不需要导包
-
字符串效果上相当于字符数组(char[]),但是底层原理是字节数组(byte[])
-
//字符串的构造方法 char[] abs={'a','b','c'};//字符数组 byte[] byt={97,98,99};//字节数组 String s2="abc";//直接复制 String str1 = new String(abs); String str2 = new String(abs); //在运行上述代码时,JVM先会创建一个字符数组，然后每次new的时候都会有一个新的地址 //虽然str1和str2的内容相同，但是它们的地址值不相同
-
若是基本数据类型,比较的是数据值是否相同
-
若是引用数据类型，比较的是地址值是否相同
-
str1.equals(str2) 比较的是str1和strt2的值是否相同
//String -> StringBuilder
//直接使用StringBuilder的构造方法
String s1="hello";
StringBuilder s2=new StringBuilder(s1);
//StringBuilder -> String
//使用StringBuilder类中一个toString方法
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("hello");
String s=stringBuilder.toString();
父类也被称为 基类或超类
继承
- 一个类如果没有父类，都默认继承Object类
- 好处
- 提高了代码的复用性(多个类的成员可以放到一个类中)
- 提高了代码的维护性(若代码需要修改，修改一处即可)
- 弊端
- 类的耦合性增强，当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性
- 子类局部范围找
- 子类成员范围找
- 父类成员范围找(第一个父亲没有，继续找第二个父亲，知道最后一个父亲还没有的话就会报错)
//父类
public class Fu {
int age=40;
}
//子类_1
public class Zi_1 extends Fu {
int height=175;
public void showZi(){
System.out.println(age+","+height);
}
}
//子类_2
public class Zi_2 extends Fu {
int height=175;
int age=20;
public void showZi(){
System.out.println(age+","+height);
}
}
//子类_3
public class Zi_3 extends Fu {
int height=175;
int age=20;
public void showZi(){
int age=10;
System.out.println(age+","+height);
}
}
//调用
public class Test {
public static void main(String[] args) {
//测试1
Zi zi_1 = new Zi_1();
zi_1.showZi();//此时,结果为 40 175
//测试2
Zi zi_2 = new Zi_2();
zi_2.showZi();//此时,结果为 20 175
//测试3
Zi zi_3 = new Zi_3();
zi_3.showZi();//此时,结果为 10 175
}
}
//结论：使用一个变量的时候，程序首先会在方法内部去找，如果该方法内部不存在该变量，那么就回去本类的成员变量里面去找，如果还没有，就会去父类成员变量里面去找。
- this&&super
public class Fu {
int age=40;
}
//子类
public class Zi_3 extends Fu {
int age=20;
public void showZi(){
int age=10;
System.out.println(age);//10
System.out.println(this.age);//20 this代表 本类 中成员变量的引用
System.out.println(super.age);//40 super 父类对象的引用
}
}
继承中构造方法的访问特点
-
子类中所有类型的构造方法(有参构造and无参构造)都会 默认的访问父类的无参构造方法
- 原因
- 子类会继承父类中的数据，可能还会使用父类中的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
- 每一个子类构造方法的默认第一条语句都是: super()
- 原因
-
如果父类中没有无参构造方法？
public class Fu { int age=10; public Fu(int age){ } }- 用super显示的调用父类中有参构造方法 super(20);
- 在父类中自己亲自提供一个无参构造方法
-
子类中出现了和父类一模一样的方法声明
-
如果父类中的方法被final状态修饰符修饰，则子类不可以重写父类中这个被final修饰的方法,子类虽然不可以重写父类中被final修饰符修饰的方法，但是在实例化子类对象后还是可以调用父类中这个被final修饰符修饰的方法的
//父类 public class Fu { public final void call(String name){ System.out.println("给"+name+"打电话"); } } //子类 public class Zi extends Fu { @Override public void call(String name){//无法重写，即使加上final也不行 System.out.println("视频电话"); super.call(name); } } -
@Overrid
- 是一个注解
- 可以帮助我们检查重写方法的正确性
-
父类中私有内容(private void call(){})子类不可能重写
-
子类方法的访问权限不能比父类低(public>默认>私有)
