Object类+final关键字+抽象类及抽象方法

客官°小女子只卖身不卖艺 2024-04-09 02:03 29阅读 0赞

## Object类+final关键字+抽象类及抽象方法 ##

### 一、Object类 ###

#### 含义：该类是所有的类的基类/超类，一个类没有明确继承的父类，都默认继承Object ####

#### 1.equals()：比较两个对象的内存地址 ####

> public boolean equals(Object obj) \{  
> return (this == obj);  
> \}

public class A {
        
    
    }

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		A a1 = new A();//0x001
    		A a2 = new A();//0x002
    		
    		//false
    		System.out.println(a1 == a2);//比较内存地址
    		//false
    		System.out.println(a1.equals(a2));//比较内存地址
    	}
    }

#### 2.getClass()：获取该类的class对象 ####

##### 作用：后续我们会学习反射机制，获取到类的class对象就意味着该类所有的代码对于我们来说都是透明的，我们就可以为所欲为 #####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		A a1 = new A();//0x001
    		 A a2 = new A();//0x002
    		 
    		 Class<? extends A> clazz1 = a1.getClass();//获取a1对象所属类的class对象
    		 Class<? extends A> clazz2 = a2.getClass();//获取a2对象所属类的class对象	 
    		 
    		 //获取A类的全路径：com.qf.test01.A
    		 //获取A类的全路径：com.qf.test01.A
    		 System.out.println("获取A类的全路径：" + clazz1.getName());
    		 System.out.println("获取A类的全路径：" + clazz2.getName());
    		 
    		 System.out.println(clazz1 == clazz2);//true
    	}
    	
    }

#### 3.hashCode()：获取该对象的hash码 ####

##### 理解hash码：hash码不等于内存地址，hash码根据内存地址+算法获取出来的一个值 #####

public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		
    		A a1 = new A();//0x001
    		A a2 = new A();//0x002
    		
    		int hashCode1 = a1.hashCode();
    		int hashCode2 = a2.hashCode();
    		
    		System.out.println(hashCode1);//366712642
    		System.out.println(hashCode2);//1829164700
    	}
    }

#### 4.toString()：获取该对象的字符串表示(将对象转换为字符串) ####

> public String toString()\{
> 
> return getClass().getName() + “@” + Integer.toHexString(hashCode());
> 
> \}
> 
> //Integer.toHexString(hashCode()); – 将10进制的hash码转换为16进制

public class Test04 {
        
    
    	public static void main(String[] args) {
        
    		A a1 = new A();
    		
    		//com.qf.test01.A@15db9742
    		System.out.println(a1);
    		System.out.println(a1.toString());//默认调用toString
    	}
    }

### 二、深入Object ###

#### 1.getClass()：在反射机制的技术点时去深入 ####

#### 2.hashCode()：在集合的技术点时去深入 ####

#### 3.Object - equals()：比较两个对象的内存地址是否相同 ####

##### 标杆作用：比较两个对象是否相同，Object不同的子类有不同的比较规则，所以不同的子类重写即可 #####

#### 4.Object - toString：获取对象的字符串表示 ####

##### 标杆作用：获取对象的字符串表示，Object不同的子类有不同的属性，所以不同的子类重写即可 #####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		User user1 = new User("123456789","123123");
    		User user2 = new User("123456789","123123");
    		
    		System.out.println(user1.equals(user2));//true
    		
    		System.out.println(user1.toString());//123456789----123123
    		System.out.println(user2.toString());//123456789----123123
    		
    		System.out.println("---------------------------");
    		
    		Student stu1 = new Student("孤独求败",'男',20,"2022","011");
    		Student stu2 = new Student("孤独求败",'男',20,"2022","011");
    		Student stu3 = new Student("东方鱼儿",'女',18,"2023","011");
    		
    		System.out.println(stu1.equals(stu2));//true
    		System.out.println(stu1.equals(stu3));//false
    		
    		System.out.println(stu1);//Student [name= 孤独求败,sex=男,age=20,classId=2022,id=011]
    		System.out.println(stu2);//Student [name= 孤独求败,sex=男,age=20,classId=2022,id=011]
    		System.out.println(stu3);//Student [name= 东方鱼儿,sex=女,age=18,classId=2023,id=011]
    		
    	}
    }

public class User {
        
    	
    	private String username;
    	private String password;
    	
    	public User() {
        
    		
    	}
    
    	public User(String username, String password) {
        
    		super();
    		this.username = username;
    		this.password = password;
    	}
    
    	public String getUsername() {
        
    		return username;
    	}
    
    	public void setUsername(String username) {
        
    		this.username = username;
    	}
    
    	public String getPassword() {
        
    		return password;
    	}
    
    	public void setPassword(String password) {
        
    		this.password = password;
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
        
    
    		if(this == obj){
        
    			return true;
    		}
    		
    		
    		//向下转型
    		User use = (User) obj;
    		if (this.username.equals(use.username)) {
        
    			return true;
    		}
    		return false;
    	}
    	
    	@Override
    	public String toString() {
        
    
    		return username + "----" + password;
    	}
    }

public class Student {
        
    
    	private String name;
    	private char sex;
    	private int age;
    	private String classId;
    	private String id;
    	
    	public Student() {
        
    		
    	}
    
    	public Student(String name, char sex, int age, String classId, String id) {
        
    		super();
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    		this.classId = classId;
    		this.id = id;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public char getSex() {
        
    		return sex;
    	}
    
    	public void setSex(char sex) {
        
    		this.sex = sex;
    	}
    
    	public int getAge() {
        
    		return age;
    	}
    
    	public void setAge(int age) {
        
    		this.age = age;
    	}
    
    	public String getClassId() {
        
    		return classId;
    	}
    
    	public void setClassId(String classId) {
        
    		this.classId = classId;
    	}
    
    	public String getId() {
        
    		return id;
    	}
    
    	public void setId(String id) {
        
    		this.id = id;
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
        
    		if (this == obj) {
        
    			return true;
    		}
    	    Student stu = (Student) obj;
    	    if ((this.classId.equals(stu.classId)) && (this.id.equals(stu.id))) {
        
    			return true;
    		}
    	    return false;
    	}
    	
    	@Override
    	public String toString() {
        
    		
    		return "Student [name= " + name + ",sex=" + sex + ",age=" + age + ",classId=" + classId + ",id=" + id + "]";
    		
    	}
    }

#### 5.扩展：String底层 ####

##### 1.比较两个字符串不要使用==，String重写了Object的equals方法 #####

##### 2.String重写Object的toString方法 #####

public class Test01 {
        
    
    		public static void main(String[] args) {
        
    			
    			String str1 = new String("abc");//['a','b','c']
    			String str2 = new String("abc");//['a','b','c']
    			
    			System.out.println(str1 == str2);//false
    			System.out.println(str1.equals(str2));//true
    			
    			System.out.println(str1);//abc
    			System.out.println(str2);//abc
    			
    			System.out.println("--------------------");
    			
    			MyString m1 = new MyString("abc");
    			MyString m2 = new MyString("abc");
    			
    			System.out.println(m1 == m2);//false
    			System.out.println(m1.equals(m2));//true
    			
    			System.out.println(m1);//abc
    			System.out.println(m2);//abc
    			
    		}
    }

public class MyString {
        
    
    	private char[] value;
    
    	public MyString(String str){
        
    		value = str.toCharArray();//将字符串转换为字符数组
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
        
    		if (this == obj) {
        
    			return true;
    		}
    		MyString my = (MyString) obj;
    		
    		char[] v1 = this.value;
    		char[] v2 = my.value; 
    		
    		int len1 = v1.length;
    		int len2 = v2.length;
    		
    		if (len1 != len2) {
        
    			return false;
    		}
    		for (int i = 0; i < len1; i++) {
        
    			//比较字符的ASCII
    			if (v1[i] != v2[i]) {
        
    				return false;
    			}
    		}
    		return true;
    	}
    	
    	@Override
    	public String toString() {
        
    		return String.valueOf(value);//将字符数组转换为字符串
    	}	
    }

### 三、final关键字 – 最终的 ###

#### 1.作用： ####

##### 1.修饰类：该类不能被继承 #####

##### 2.修饰方法：该方法不能被子类重写 #####

##### 3.修饰变量：该变量变为常量，不能被重新赋值（常量存储在常量池中，直到项目结束时才会被销毁） #####

#### 2.经验： ####

##### 1.工具类可以使用final修饰 #####

##### 2.程序中遇到一个不变的量，就可以设置为常量 #####

##### 3.常量的命名规范：所有字母大写，单词与单词之间使用下划线隔开 #####

public class Test01 {
        
         public static void main(String[] args) {
        
    		
    	}
    }

//final修饰类：该类不能被继承
    //public final class A {
        
    public class A {
        
    
    	//final修饰方法：该方法不能被子类重写
    	//public final void method(){
        
    		public void method(){
        
    			System.out.println("父类的方法");
    		}
    }

public class B extends A{
        
    
    	@Override
    		public void method() {
        
    		//final修饰变量：该变量变为常量，不能被重新赋值
    		//（常量存储在常量池中，直到项目结束时才会被销毁）		
    			final int i = 100;
    			System.out.println("子类重写父类的方法" + i);
    		}
    }

### 四、final扩展 之 单例模式 ###

#### 前言：new对象的过程我们称之为实例化 ####

#### 单例模式：该类的对象在程序中只有一个 ####

public class Test01 {
        
    	public static void main(String[] args) {
        
    		A a1 = A.getInstance();
    		A a2 = A.getInstance();
    		System.out.println(a1 == a2);//true
    		
    //		A.xxx();
    		
    		System.out.println("----------------");
    		
    		B b1 = B.getInstance();
    		B b2 = B.getInstance();
    		System.out.println(b1 == b2);//true
    		
    //		B.xxx();
    	}
    }

#### 1.单例模式 - 饿汉式 ####

##### 1.含义：使用到该类，就会将class文件加载到方法区，JVM会扫描该类的静态属性，A类对象就会被创建 #####

##### 2.步骤： #####

##### 1.私有化构造方法（目的：不能让外界直接new对象） #####

##### 2.创建A类的对象，设置为静态常量 #####

> ###### 设置静态的目的：直接使用类名调用 ######
> 
> ###### 设置常量的目的：不能让外界修改，外界只能使用，不能重新赋值 ######

##### 3.私有化静态常量，并且设置获取a对象的方法（getInstance()） #####

public class A {
        
    	
    	//静态常量属性
    		private static final A a = new A();
    		
    		private A () {
        
    			
    		}
    		public void method() {
        
    			System.out.println("A类中的成员方法");
    		}
    		
    		//获取A类对象的方法
    		public static A getInstance(){
        
    			return a;
    		}
    		
    		public static void xxx(){
        
    			System.out.println("A类中的静态方法");
    		}
    }

#### 2.单例模式 - 懒汉式 ####

##### 含义：直到用户调用getInstance时，B类的对象才会被创建 #####

public class B {
        
    
    	//静态常量属性
    	private static B b;
    	private B(){
        
    		
    	}
    	
    	public void method(){
        
    		System.out.println("B类中的成员方法");
    	}
    	
    	//获取B类对象的方法
    	public static B getInstance(){
        
    		if (b == null) {
        
    			b = new B();
    		}
    		return b;
    	}
    	
    	public static void xxx(){
        
    		System.out.println("B类的静态方法");
    	}
    }

### 五、抽象类及抽象方法 ###

#### 需求：编写人类和其子类(日本人、中国人) ####

public class Test01 {
        
    
    		public static void main(String[] args) {
        
    			
    			Japanese j = new Japanese("小岛惠子", '女', 18, "昭和");
    			j.eat();
    			j.sleep();
    			j.playVideo();
    			
    			System.out.println("-----------------");
    			
    			SiChuan sc = new SiChuan("项羽", '男', 23, "1234567890");
    			sc.eat();
    			sc.hobby();
    			sc.sleep();
    			
    			System.out.println("-----------------");
    			
    			GuangDong gd = new GuangDong("亚父", '男', 85, "097654321");
    			gd.eat();
    			gd.hobby();
    			gd.sleep();
    		}
    }

//抽象类
    public abstract class Person {
        
    
    	private String name;
    	private char sex;
    	private int age;
    	
    	public Person() {
        
    	}
    
    	public Person(String name, char sex, int age) {
        
    		super();
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public char getSex() {
        
    		return sex;
    	}
    
    	public void setSex(char sex) {
        
    		this.sex = sex;
    	}
    
    	public int getAge() {
        
    		return age;
    	}
    
    	public void setAge(int age) {
        
    		this.age = age;
    	}
    	
    	
    	//抽象方法：交给非抽象的子类去实现(重写)
    	//应用场景：该方法从程序设计的角度应该在父类类，但是不好实现，就将该方法设置为抽象方法，
    	//交给非抽象的子类去重写即可
    	
    	public abstract void eat();
    	
    	public void sleep(){
        
    		System.out.println(this.name + "睡觉觉");
    	}
    }

public class Japanese extends Person {
        
    
    	private String yearNum;
    	
    	public Japanese(){
        
    	  
      }
    
    	public Japanese(String name, char sex, int age, String yearNum) {
        
    		super(name, sex, age);
    		this.yearNum = yearNum;
    	}
    
    	public String getYearNum() {
        
    		return yearNum;
    	}
    
    	public void setYearNum(String yearNum) {
        
    		this.yearNum = yearNum;
    	}
    
    	@Override
    	public void eat() {
        
    		System.out.println(super.getName() + "吃马赛克...");
    		
    	}
    	
    	public void playVideo() {
        
    		System.out.println(super.getName() + "拍电影...");
    	}
    }

public class GuangDong extends Chinese
    	public GuangDong(){
        
    		
    	}
    	
    	
    
    	public GuangDong(String name, char sex, int age, String id) {
        
    		super(name, sex, age, id);
    		
    	}
    
    
    
    	@Override
    	public void hobby() {
        
    		System.out.println(super.getName() + "喜欢收租、做生意...");
    		
    	}
    
    	@Override
    	public void eat() {
        
    		System.out.println(super.getName() + "吃海鲜、肠粉");
    		
    	}
    	
    }

public abstract class Chinese extends Person {
        
    	
    	private String id;
    	
    	public Chinese(){
        
    		
    	}
    
    	public Chinese(String name, char sex, int age, String id) {
        
    		super(name, sex, age);
    		this.id = id;
    	}
    
    	public String getId() {
        
    		return id;
    	}
    
    	public void setId(String id) {
        
    		this.id = id;
    	}
    
    	public abstract void hobby();
    }

public class SiChuan extends Chinese {
        
    
    	public SiChuan(){
        
    		
    	}
    	
    	
    
    	public SiChuan(String name, char sex, int age, String id) {
        
    		super(name, sex, age, id);
    		
    	}
    
    
    
    	@Override
    	public void hobby() {
        
    		System.out.println(super.getName() + "喜欢打麻将、炸金花...");
    		
    	}
    
    	@Override
    	public void eat() {
        
    		System.out.println(super.getName() + "吃火锅、烧烤");
    		
    	}
    	
    	
    }

Object类+final关键字+抽象类及抽象方法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读