赋值及运算
- 扩展赋值运算符自带强转功能 +=，-=，*=，/=
short s=5;
s+=10; //相当于 s=(short) (s+10)
s=s+10; //报错，数值参与运算相当于两个int相加，赋值给short需要强制类型转换
- double运算存在误差
二进制计算中无法精确表示1/10，就像十进制中无法精确表示1/3
private static double money=3.0;
private static double price=2.9;
public static void main(String[] args) {
double left=money-price;
System.out.println(left); //0.10000000000000009
}
精确运算不使用double和float，转使用BigDecimal
-
long型计算，如果有可能溢出，建议第一个数值就加L
long.jpg -
char的使用
char.jpg -
基本数据类型转换
基本类型转换.jpg
字符串连接
字符串跟别的相加都转为字符串
System.out.println(10+""+3); //103
System.out.println(""+10+3); //103
System.out.println(10+3+""); //13
数组的复制
System.arraycopy(源数组, 原数组拷贝起始下标, 目的数组, 目的数组起始下标, 拷贝元素个数);
Arrays.copyOf(源数组, 目的数组长度);
int[] a= {1,3,7,2};
int[] b=new int[5];
System.arraycopy(a, 1, b, 2, 3);
System.out.println(Arrays.toString(b)); //[0, 0, 3, 7, 2]
int[] c = Arrays.copyOf(a, 7);
System.out.println(Arrays.toString(c)); //[1, 3, 7, 2, 0, 0, 0]
a = Arrays.copyOf(a, a.length + 1); //数组扩容
System.out.println(Arrays.toString(a)); //[1, 3, 7, 2, 0]
冒泡排序
private static int[] generateArr() {
int[] arr = new int[6];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * 100);
}
return arr;
}
private static int[] bubbleSort(int[] arr) {
/**
* 冒泡排序算法，如长度为6的数组：arr=[79,6,55,2,8,11]
* 1、第1轮，比较5次 2、第2轮，比较4次 ... 5、第5轮，比较1次
*/
for (int i = 0; i < arr.length - 1; i++) { //外层控制第几轮
for (int j = 0; j < arr.length - 1 - i; j++) { //内层控制这一轮的内部比较
if (arr[j] > arr[j + 1]) {
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
return arr;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] myArr = generateArr();
int[] sortedArr = Arrays.copyOf(myArr,myArr.length);
System.out.println(Arrays.toString(myArr));
System.out.println(Arrays.toString(bubbleSort(sortedArr)));
}
类
类是引用类型，引用类型的变量默认值都是null，所以String name; name的默认值是null
重载overload
在java中，允许多个方法的名称相同，但是参数列表不同，称为方法的重载（overload）。重载与返回值类型无关
- 同一文件中可以包含多个类，
- public修饰的类只能有一个
- public修饰的类必须和文件名一样
构造方法
常用于实现对象成员变量的初始化
不写有默认的无参构造方法，若自己写了构造方法，就不再提供默认。
this
指代当前对象，哪个对象调用方法就是谁
this只能用在方法中
内存管理：由JVM来管理
堆：存储new出来的对象，包括实例变量
栈：存储局部变量，包括方法的参数
方法区：存储.class字节码文件，包括方法、静态变量
堆栈.jpg
引用类型之间画等号
- 指向同一个对象
-
通过一个引用对数据的修改 ，会影响另一个引用对数据的访问
引用类型相等与基本类型相等.jpg
继承
- 作用：代码复用
- 通过extends来实现继承
- 超类/父类：所有派生类所共有的属性和行为
派生类/子类：派生类所特有的属性和行为 - 派生类继承超类后，派生类具有：派生类的和超类的
- 一个超类可以有多个派生类，一个派生类只能有一个超类----单一继承性
- 继承具有传递性，孙-->父-->爷爷
- 派生类的构造方法中，若没有调用超类的构造方法，则默认super()调用超类的无参构造方法；若调用了超类的构造方法，则不再默认提供
super
指代当前对象的超类对象
super的用法：
- super.成员变量名----访问超类的成员变量
- super.方法名----访问超类的方法名
- super()----访问超类的构造方法
this指的是派生类对象
super指的是超类对象
重写
遵循两同两小一大原则
- 方法名称相同
- 参数列表相同
- 派生类的返回值类型小于或等于超类的
void时，相等
基本类型时，相等
引用类型时，小于或等于
- 派生类方法抛出的异常小于或等于超类方法的
- 派生类方法的访问权限大于或等于超类方法的
返回值示例（一般返回值类型一样）：
package test;
public class OverideDemo {
}
class Parent {
void show() {
}
int getAge() {
return 60;
}
Parent getSelf() {
return new Parent();
}
Child getMySelf() {
return new Child();
}
}
class Child extends Parent {
void show() {
}
int getAge() {
return 30;
}
// 派生类的重写方法，其返回值如果是引用类型，则小于或等于超类方法的返回值类型
Child getSelf() {
return new Child();
}
// 报错返回值类型不匹配
// Parent getMySelf() {
// return new Child();
// }
}
重载与重写的区别
重写：
- 发生在父子类中，方法名称相同，参数列表相同，方法体不同
- 遵循运行期绑定，看对象的类型来调用方法（重写被调看对象）
重载：
- 发生在一个类中，方法名称相同，参数列表不同，方法体不同
- 遵循编译期绑定，看参数/引用的类型来绑定方法
针对第二条示例：
package my.base;
public class Test1209 {
public static void main(String[] args) {
A a = new A();
B o = new C();
a.test(o); //调用超类 执行派生类show
//重载看参数[引用]类型；重写被调看对象；
}
}
class A {
void test(B o) {
System.out.println("调用超类");
o.show();
}
void test(C o) {
System.out.println("调用派生类");
o.show();
}
}
class B {
void show() {
System.out.println("执行超类show");
}
}
class C extends B {
void show() {
System.out.println("执行派生类show");
}
}
包名
作用：避免类的冲突
建议：
包名所有字母小写
域名反写 项目名称 模块名称 包名
cn.tedu.aproject.studentmaneger.Myclass