小白Java学习之路（abstract抽象类，final，接口，equals）

最新推荐文章于 2024-08-04 17:53:26 发布

一生而已

最新推荐文章于 2024-08-04 17:53:26 发布

阅读量139

点赞数 1

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_38114301/article/details/96453047

版权

java基础专栏收录该内容

15 篇文章 6 订阅

订阅专栏

常见面试题

final修饰静态常量进过方法

final 修饰的基本数据类型变量是无法进行修改的

final 修饰的引用类型的变量只保证地址不变对象中的内容可以发生改变

public class Test01 {
	//定义常量
	final static int num = 10;
	final static Dog dog = new Dog("泰迪","棕黄色");
	
	public static void main(String[] args) {
		fun(num );
		
		
		//fun(dog);
		System.out.println("main"+dog);
		
	}
	public static void fun(  ) {
		dog.setColor("黑色");
		//dog = new Dog();
		System.out.println("fun"+dog);
	}
	
	public static void fun( int num ) {
		num++;
		System.out.println(num);
	}
	
	
}

class Dog {
	private String type;
	private String color;
	public Dog() {
	}
	public Dog(String type, String color) {
		super();
		this.type = type;
		this.color = color;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	@Override
	public String toString() {
		return "Dog [type=" + type + ", color=" + color + "]";
	}
	
}

final修饰的静态常量不会导致类加载

静态成员常量不会导致类加载

静态成员常量的值在加载前无法确定那么会导致类加载

public class Test02 {
	
	final static int num  = (int)(Math.random()*33);
	static {
		System.out.println("我是静态代码块");
	}
	public static void main(String[] args) {	
		System.out.println(Test02.num);
	}
}


public class Test03 {
	public static void main(String[] args) {
		
		System.out.println(Test02.num);
		
	}
}

类的加载对象

先加载静态内容 -> 先执行静态代码块由于父子关系所以子类加载之前需要先加载父类
执行的父类的初始化块和欧构造器
准备执行子类的构造器 (先执行初始化块子类构造器中有一个super)

详细顺序

父类的静态代码块
子类的静态代码块
父类的初始化块
父类的构造器
子类的初始化块
子类的构造器

public class Test04 {
	public static void main(String[] args) {
		new S2().m();
	}
}

class F{
	static {
		System.out.println("F static");
	}
	{
		System.out.println("F init");
	}
	public F() {
		System.out.println("F construct");
	}
}

class S1 extends F{
	static {
		System.out.println("S1 static");
	}
	{
		System.out.println("S1 init");
	}
	public S1() {
		System.out.println("S1 construct");
	}
}

class S2 extends F{
	static {
		System.out.println("S2 static");
	}
	{
		System.out.println("S2 init");
	}
	public S2() {
		System.out.println("S2 construct");
	}
	public void m() {
		new S1();
	}
}

abstract抽象类

学习抽象类

父类中定义的方法不需要具体的实现步骤子类都不按照父类的做
父类中定义这个方法的目的是告诉子类一定要保证存在该方法

对于类的要求

父类中不需要定义方法的实现步骤
子类必须要重写

抽象类

包含了抽象方法的的类称之为抽象类。
被abstract修饰的类称之为抽象了

抽象方法

只要方法的声明，没有方法体。通过abstract修饰的方法称之为抽象方法

为什么需要抽象类

避免子类的随意设计
提高了代码可读性
提高了子类的健壮性

abstract class Person{
    public abstract void eat() ;
    } 
    class Chinese extends Person{
        public void eat() {
        }
    } 
    class En{
        public void eat() {
        }
}

深入理解抽象类

1:抽象类中只能包含抽象方法吗?
- 既可以定义抽象方法也可以定义普通方法
2:是否可以定义构造器
- 抽象类可以存在构造器但是无法实例化
- 抽象类中的构造器是给子类准备的
- 抽象类就是用来被继承的抽象方法就是被重写的
3:子类继承了抽象了之后一定要重写所有的抽象方法

public class Test02 {
	public static void main(String[] args) {
		// 实例化抽象类
		//Father f = new Father();
		Son s = new Son();
	}
}


abstract class Father{
	public Father() {
		System.out.println("我是抽象类的构造器");
	}
	
	public abstract void study();
	//public abstract void work();
}

class Son extends Father{
	public Son() {
		
	}
	public void study() {
		
	}
}

模板方法

将上下文中的一些不会变化的内容保留下来在父类中实现
并且定义整个程序的执行流程
将核心的业务逻辑或者是算法逻辑延迟到子类中去实现。

public class Test03 {
	public static void main(String[] args) {
		/*
		 * Tea t = new Tea(); t.flow();
		 * 
		 * Caf c = new Caf(); c.flow();
		 */
		Water w1 = new Tea();
		w1.flow();
		
		
	}
}

abstract class Water{
	private void fireWater() {
		System.out.println("咕噜咕噜咕噜");
	}
	
	public abstract void pp() ;
	
	private void drink() {
		System.out.println("墩儿~墩儿~墩儿~墩儿~");
	}
	
	public void flow() {
		fireWater();
		pp();
		drink();
	}
	
}

class Tea extends Water{
	
	public void pp() {
		System.out.println("冲泡");
	}
	
}
class Caf extends Water{
	
	
	public void pp() {
		System.out.println("搅拌");
	}

final

final修饰的变量称之为最终常量在程序运行期间其值不可发生改变
final修饰的类不可以被继承：太监类
final修饰的方法不可以被重写

public class Test01 {
	public static void main(String[] args) {
		String str = "991010010110";
	}
}
/* final */ class Person{
	
	public final void study() {
		System.out.println("必须早上5点起床");
	}
}

class Student extends Person{
	
	public void study() {
		System.out.println("这谁顶得住");
	}
}

接口

接口是一个规范是一套标准比抽象了还抽象。

接口的定义

修饰符 interface 接口名{}
接口中的变量都是公开的静态的最终常量值默认情况下变量都是public static final修饰
接口中可以定义静态方法(不建议1.8之后才能使用)
接口中定义的对象方法都是抽象方法接口中的方法默认就是通过abstract修饰的
接口中的默认方法从1.8之后才开始被使用允许在接口中定义default方法而且存在方法体

interface Fly{
    int SPEED = 10;
    default void method() {
    } 
    public static void fun1() {深入理解接口
    } 
    public abstract void fun2() ;
}

深入理解接口

修饰符 class 类名 extends 父类 implements 接口

接口就是一套规则，用来定义具体要做哪些事情，但是所有事情的具体实现都会延迟到实现类中完成。接口只需要定义has-a的关系，如果你是什么，则你具备了什么能力。

接口深入：

1、类和接口直接通过implements 发生关系类实现接口
2、类必须要实现接口中的所有抽象方法
3、一个类可以实现多个接口类名 implements 接口1，接口2。。。。。
4、一个类实现了接口之后要将当前接口以及接口的父接口中的所有抽象方法全部重写
5、接口可以多继承
6、接口无法实例化
7、接口没有构造器
8、接口中也可以使用多态

public class Test03 {
	public static void main(String[] args) {
		
		Fly f = new SuperMan();//接口变量指向实现类对象
		f.fly();
		
	}
}


interface Fly extends Comparator,Serializable{
	
	/*
	 * public Fly() {
	 * 
	 * }
	 */
	
	
	public void fly();
	//public void method();
}


class SuperMan implements Fly/* , Comparator */{
	public void fly() {
		System.out.println("飒······");
	}

	
	public int compare(Object o1, Object o2) {
		 // TODO Auto-generated method stub
	  return 0; 
	}
	 
}

equals方法

equals方法就是用来比较两个对象是否相等的，默认Object的equals方法比较是两个对象的地址。

public class Test01 {
	public static void main(String[] args) {
		
		
		//创建两个user对象
		User u1 = new User("zhangsan","123");
		User u2 = new User("zhangsan","123");
		
		System.out.println(u1==u2);//== 比较两个对象的地址 
		
		System.out.println(u1.equals(u2));
		
		String str = "哎~~~";
		System.out.println(u1.equals(str));
		
		User u3 = new User();
		System.out.println(u3.equals(null));
		
		
	}
}
class User{
	private String name;
	private String pwd;
	
	public User() {
		// TODO Auto-generated constructor stub
	}

	public User(String name, String pwd) {
		super();
		this.name = name;
		this.pwd = pwd;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

	public String toString() {
		return "User [name=" + name + ", pwd=" + pwd + "]";
	}
	
	@Override
	public boolean equals(Object obj) {//Object obj = u2; Object obj = "哎~~~";
		
		if(!(obj instanceof User)) {
			return false;
		}
		
		//将obj强转为user
		User other = (User)obj;
		
		if(this.name!=null&&this.pwd!=null) {
			//比较用户名和密码
			if(this.name.equals(other.name)&&this.pwd.equals(other.pwd)) {
				return true;
			}
		}
		return false;
	}	
}