仅以各种代码及注释来记录java学习之路
抽象类
public class AbstractTest {
public static void main(String[] args) {
//new Account();
}
}
abstract class Account{
//抽象类
//无参构造函数
public Account(){
}
//有参构造函数
public Account(String s){
}
//抽象方法
public abstract void move();
}
class CreditAccount extends Account{
@Override
public void move() {
//子类不是抽象类，所以继承过来的抽象方法move()需要重写一下。
}
}
Object类
import java.util.Objects;
public class Object_class {
public static void main(String[] args) {
//toString源代码
MyTime t = new MyTime(2022, 3, 4);
String s = t.toString();
System.out.println(s);//输出结果：MyTime@4554617c
//重写后输出结果：2022年3月4日
System.out.println(t);
System.out.println(t.toString());//上面三种输出结果一样
//equals方法源代码
//判断两个基本数据类型的数据是否相等直接使用 == 就行
int a = 100;
int b = 100;
System.out.println(a == b);//返回true false
//判断两个java对象（引用数据类型）是否相等不能使用 == ，因为 == 比较的是两个对象的内存地址
MyTime t1 = new MyTime(2022, 3, 4);
MyTime t2 = new MyTime(2022, 3, 4);
System.out.println(t1.equals(t2));//重写前输出false, 重写后输出true
//finalize()方法
//源代码：
//protected void finalize() throws Throwable { }
//finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的，该方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法
//当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法
//finalize()方法实际上是SUN公司为java程序员准备的一个时机，垃圾销毁时机，如果希望在对象销毁时执行一段代码的话，这段代码要写到finalize()方法当中。
//
for(int i = 0; i < 1000; i++){
Student s1 = new Student();
s1 = null;
}
System.gc();//建议启动垃圾回收器
//hashCode()方法
//源代码
//public native int hashCode();
//这个方法不是抽象方法，带有native关键字，底层调用C++程序
//hashCode()方法返回的是哈希码，实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值，所以hashCode()方法的执行结果可以看作是一个Java对象的内存地址
Object o = new Object();
System.out.println(o.hashCode());
Object o1 = new Object();
System.out.println(o1.hashCode());
//clone()方法
//转载自：https://blog.csdn.net/lovezhaohaimig/article/details/80372233
//浅克隆是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。
//深克隆不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。举例来说更加清楚：
}
}
class MyTime{
int year;
int month;
int day;
public MyTime(){
}
public MyTime(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
@Override
public String toString() {
return this.year + "年" + this.month + "月" + this.day + "日";
}
//自动生成的equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyTime myTime = (MyTime) o;
return year == myTime.year && month == myTime.month && day == myTime.day;
}
}
class Student{
int no;
String school;
public Student() {
}
public Student(int no, String school) {
this.no = no;
this.school = school;
}
//重写toString方法
public String toString(){
return "学号" + no + "，所在学校名称" + school;
}
//重写equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return no == student.no && Objects.equals(school, student.school);
}
@Override
protected void finalize() throws Throwable {
System.out.println("即将被销毁！");
}
}
接口
public class InterfaceTest {
public static void main(String[] args) {
System.out.println(MyMath.e);
System.out.println(MyMath.PI);
//多态
MyMath mm = new MyMathImpl();
int result = mm.sum(10, 20);
System.out.println(result);
//多态 都是父类引用指向子类引用
A a = new D();
B b = new D();
a.m1();//在这里不能访问m2()
//向下转型之后才能访问m2()
B b2 = (B) a;
b2.m2();
//接口与接口之间在进行强制类型转换的时候没有继承关系也可以强转
//但是在运行的时候可能会出现ClassCastException异常
B b1 = new E();
A a1 = (A)b1;
//多态
Flyable f = new Cat();
f.fly();
}
}
interface A{
//编译后在out文件夹中也生成.class文件
void m1();
}
interface B{
void m2();
}
class E implements B{
@Override
public void m2() {
}
}
interface C extends A, B{
}
//实现多个接口，就类似于多继承。
class D implements A, B{
//Alt + Shift +Enter快速重写
//实现A中的接口m1
@Override
public void m1() {
}
//实现B中的接口m2
@Override
public void m2() {
System.out.println("调用了D中的m2接口");
}
}
interface MyMath{
//常量
public static final double PI = 3.1415926;
double e = 2.71828;
//抽象方法
public abstract int sum(int a, int b);
int sub(int a, int b);
}
class MyMathImpl implements MyMath{
//重写/覆盖/实现 接口中的方法(通常叫做实现
public int sum(int a, int b){//public不写会报错
return a + b;
}
public int sub(int a, int b){
return a - b;
}
}
class Animal{
}
//能插拔的是接口
interface Flyable{
void fly();
}
//要飞就要实现这个接口
class Cat extends Animal implements Flyable{
@Override
public void fly() {
System.out.println("飞猫");
}
}
//蛇类，没有实现Flyable接口就不能飞
class Snake extends Animal{
}
内部类
public class InnerClass {
static class Inner1{
//静态内部类
}
class Inner2{
//没有static叫做实例内部类
}
public void doSome(){
int i = 100;
class Inner3{
//局部内部类
}
}
public static void main(String[] args) {
MyMath1 mm = new MyMath1();
mm.mySum(new ComputeImpl(), 100, 200);
mm.mySub(new ComputeSub() { //该接口不需要实现类，直接在创建接口的时候实现
@Override
//匿名内部类创建的对象 《高端》
public int sub(int a, int b) {
return a - b;
}
}, 200, 100);
}
}
//负责计算的接口
interface Compute{
//抽象方法
int sum(int a, int b);
}
//负责计算差的接口
interface ComputeSub{
//该接口不需要实现类，直接在创建接口的时候实现
int sub(int a, int b);
}
//实现接口
class ComputeImpl implements Compute{
@Override
public int sum(int a, int b) {
return a + b;
}
}
//数学类
class MyMath1{
//数学求和方法
public void mySum(Compute c, int a, int b){
System.out.println(a + "+" + b + "=" + c.sum(a, b));
}
//数学求差方法
public void mySub(ComputeSub c, int a, int b){
System.out.println(a + "+" + b + "=" + c.sub(a, b));
}
}
