一、八种数据类型
- 4种整数类型：byte、short、int、long
- 2种浮点类型：float、double
- 字符类型：char
- 布尔类型：boolean
（一）赋值
- 没有超出变量的取值范围可直接赋值，否则出错。
- 将数字类型转换成字符类型时，只使用整数的低 16 位（浮点数类型将整数部分转换成字符类型）。
- 布尔类型不能与其他基本数据类型进行转换。
int a = (int) 800000000000L; //没加L出错，L表示其为long类型！
byte b = 30;
short s = (short) '\u8000';
long l = 123323;
float f = (float) 3.14; //小数默认是double类型，float要转换！（二）参数传递方式
Java只有值传递！
传递的类型无论是值类型还是引用类型，Java 都会在调用栈上创建一个副本，不同的是，对于值类型而言，这个副本就是整个原始值的复制；而对于引用类型而言，由于引用类型的实例存储在堆中，在栈上只有它的一个引用，指向堆的实例，其副本也只是这个引用的复制，而不是整个原始对象的复制。
二、一些关键字、方法、接口
（一）static
public class StaticTest {
public static void main(String[] args) {
// 静态初始化块的优先级最高，会最先执行，在非静态初始化块之前执行。
// 静态初始化块只在类第一次被加载时执行，非静态初始化块在每次创建对象时执行一次，
// 因此创建了多少个对象，就会执行多少次非静态初始化块。
Son son = new Son(1);
System.out.println("--------");
Son son1 = new Son(2);
}
}
class Parent {
{
System.out.println("Parent非静态代码块");
}
static {
System.out.println("Parent静态代码块");
}
public Parent() {
System.out.println("Parent构造函数");
}
}
class Son extends Parent {
private int num;
private static int id = 2;
static {
System.out.println("Son静态代码块");
}
{
num = 2;
System.out.println("Son非静态代码块");
}
public Son(int num) {
System.out.println("Son构造函数");
this.num = num;
}
//静态方法只能访问静态的类成员，这里访问不到num
public static void print_id() {
System.out.println(id);
}
//实例方法既可以访问实例的类成员，也可以访问静态的类成员。
public void print_Info() {
System.out.println(num);
System.out.println(id);
}
}
/*
结果为：
Parent静态代码块
Son静态代码块
Parent非静态代码块
Parent构造函数
Son非静态代码块
Son构造函数
--------
Parent非静态代码块
Parent构造函数
Son非静态代码块
Son构造函数
*/（二）final
// 修饰普通基本类型变量时，final能使变量的值无法改变，变量的值无法再被赋值。
// 下面无法进行a的赋值了。
final int a = 0;
// 修饰对象引用的变量时，final能保证变量不能再引用其他的对象，
// 不能保证当前引用对象内部的值不被修改。
final int[] b = new int[5];
b[0] = 1;（三）equals
判断两个对象内容是否相同，应使用 equals 方法，而不能使用 ==，因为 == 作用于对象时判断的是两个对象是否具有相同的引用值。
（四）Comparable
public class OoTest {
public static void main(String[] args) {
List<People> list = new ArrayList<People>();
list.add(new People("11",2,1));
list.add(new People("22",4,2));
list.add(new People("33",9,3));
list.add(new People("44",1,4));
Collections.sort(list);
for (People l : list) {
System.out.println(l);
}
}
}
class People implements Comparable<People> {
private String name;
private int age;
private int id;
public People(String name, int age, int id) {
= name;
this.age = age;
this.id = id;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
@Override
public int compareTo(People o) {
if (this.age > o.age) {
return 1;
}
return -1;
}
}三、面向对象的特征
封装、继承、多态
- 封装：private，隐藏了类的内部实现机制，便于修改，增加代码可维护性；
- 继承：extend，从已有的类中派生出新的类，增强代码的复用性；
- 多态：三要素，增加了代码的可移植性、健壮性。
- 继承
- 重写
- 父类引用指向子类对象
四、内部类
分为：静态内部类，成员内部类，局部内部类，匿名内部类四种
abstract class Inner4 {
public String name;
public Inner4(String name) {
= name;
}
public abstract void print();
}
public class TestClass {
private int a;
private static int b;
//静态内部类
public static class Inner {
//静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。
//静态内部类可以访问外部类所有的静态变量和方法
private static int c = 1;
public static void print() {
System.out.println(b);
System.out.println(c);
}
}
//成员内部类
public class Inner2 {
//成员内部类不能定义静态方法和变量
public void print() {
System.out.println(a);
System.out.println(b);
}
}
//局部内部类
public void print() {
class Inner3 {
public void print() {
System.out.println(a);
}
}
new Inner3().print();
}
public void testInner4(Inner4 inner4) {
System.out.println(inner4.name);
}
public static void main(String[] args) {
TestClass testClass = new TestClass();
testClass.print();
TestClass.Inner.print();
//匿名内部类
testClass.testInner4(new Inner4("555") {
@Override
public void print() {
System.out.println();
}
});
}
}五、拷贝
Student类如下：
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
@AllArgsConstructor
@NoArgsConstructor
@Data
@ToString
public class Student implements Cloneable{
public String name;
public Birth birth;
@Override
protected Student clone() {
try {
return (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
public Student clone2() {
Student s = null;
try {
s = (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
s.birth = (Birth) birth.clone();
return s;
}
}
@AllArgsConstructor
@Data
@ToString
class Birth implements Cloneable{
int year;
int month;
@Override
protected Birth clone() {
try {
return (Birth) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}（一）直接复制
复制的是引用，即指向同一个对象！
public static void directCopy() {
Student s1 = new Student("A",new Birth(1999,10));
Student s2 = s1;
System.out.println(s1.equals(s2));
s1.setName("B");
System.out.println(s2);
}（二）浅拷贝
深浅拷贝可以通过构造函数，也可以通过实现Cloneable接口实现，这里采用继承Cloneable接口实现。
浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
public static void shallowCopy() {
Student s1 = new Student("A", new Birth(1999,10));
Student s2 = s1.clone();
s1.setName("B");
s1.birth.setYear(1998);
System.out.println(s2);
}（三）深拷贝
深复制把要复制的对象所引用的对象都复制！
public static void deepCopy() {
Student s1 = new Student("A",new Birth(1998,2));
Student s2 = s1.clone2();
s1.setName("B");;
s1.birth.setYear(2000);
System.out.println(s1);
System.out.println(s2);
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
