Day12
Day12
一,Object类
1,Object的含义
public class Test04 {
/**
* 知识点：Object类
* 含义：所有类的基类/超类，是所有类的祖先类
* 理解：一个类没有明确继承的父类，都默认继承Object
*
* equals()：比较两个对象的内存地址是否相同
* public boolean equals(Object obj) {
return (this == obj);
}
*
* getClass()：获取该类的class对象
* 前言：使用到一个类，该类的class文件会加载到方法区中，同时会在堆中创建该类的class对象，用于 class文件的访问入口
*
* hashCode()：获取对象的hash值
* 注意：hash值是通过内存地址加上hash算法算出来的数据，hash值不等于内存地址
*
* toString()：将对象转换为字符串格式
* public String toString(){
* return getClass().getName() + "@" + Integer.toHexString(hashCode());
* }
*/
public static void main(String[] args) {
Object obj = new Object();
//java.lang.Object@15db9742
System.out.println(obj);//直接打印对象，默认调用toString()
System.out.println(obj.toString());
Object obj1 = new Object();//0x001
Object obj2 = new Object();//0x002
System.out.println(obj1 == obj2);//false
System.out.println(obj1.equals(obj2));//false
int hashCode1 = obj1.hashCode();
System.out.println(hashCode1);
int hashCode2 = obj2.hashCode();
System.out.println(hashCode2);
}
}
2,Object的使用
public class Test01 {
/**
* 知识点：Object的使用
*
* Object - equals：比较两个对象是否相同，不同子类判断两个对象的标准是不一样的，所以不同子类重写即可
* Object - toString：获取对象的字符串表示，不同的子类有不同的属性，所以不同的子类重写即可
*/
public static void main(String[] args) {
User user1 = new User("1445584980", "123123", "何老师");
User user2 = new User("1445584980", "123123", "何老师");
System.out.println(user1.equals(user2));//true
//默认调用toString()
System.out.println(user1);//1445584980 -- 123123 -- 何老师
System.out.println(user2);//1445584980 -- 123123 -- 何老师
}
}
public class User {
private String username;
private String password;
private String name;
public User() {
}
public User(String username, String password, String name) {
this.username = username;
this.password = password;
this.name = name;
}
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;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 判断两个用户对象是否相同：按照账号
*/
@Override
public boolean equals(Object obj) {
if(this == obj){
return true;
}
User user = (User) obj;
if(this.username.equals(user.username)){
return true;
}
return false;
}
@Override
public String toString() {
return username + " -- " + password + " -- " + name;
}
}
3,Object的深入理解
public class Test01 {
/**
* 知识点：Object深度理解String
*/
public static void main(String[] args) {
String str1 = new String("abc");
String str2 = new String("abc");
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);
System.out.println(m2);
}
}
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 length = v1.length;
if(length != v2.length){
return false;
}
for (int i = 0; i < length; i++) {
if(v1[i] != v2[i]){//比较字符数组的元素的Unicode
return false;
}
}
return true;
}
@Override
public String toString() {
String str = "";
for (char element : value) {
str += element;
}
return str;
}
}
二,final
理解：最终的
作用： 1.修饰类：类不能被继承 2.修饰方法：方法不能被重写 3.修饰变量：变成常量
//final修饰类，类不能被继承 -- 最终的类
//public final class A {
public class A {
//final修饰方法，方法不能被重写 -- 最终的方法
//public final void method(){}
public void method(){}
}
public class B extends A{
@Override
public void method() {
//final修饰变量，变量变成常量
final int I = 100;
System.out.println(I);
}
}
三,抽象类和抽象方法
测试类:
public class Test01 {
/**
* 知识点：抽象类及抽象方法
*
* 需求：创建人类及其子类(中国人、日本人)
*/
public static void main(String[] args) {
Japanese j = new Japanese("波多野结衣", '女', 18, "令和");
j.eat();
j.sleep();
System.out.println("-------------------");
SiChuan sc = new SiChuan("徐灿", '男', 23, "1234567890");
sc.eat();
sc.sleep();
System.out.println("-------------------");
GuangDong gd = new GuangDong("李嘉诚", '男', 96, "0987654321");
gd.eat();
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) {
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 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 hobbies();
}
非抽象子类继承抽象方法,重写了父类的抽象方法
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(this.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 hobbies() {
System.out.println(super.getName() + "喜欢喝茶、做生意");
}
@Override
public void eat() {
System.out.println(super.getName() + "吃潮汕牛肉火锅、肠粉、白切鸡");
}
}
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 hobbies() {
System.out.println(super.getName() + "喜欢打麻将、炸金花、斗牛牛");
}
@Override
public void eat() {
System.out.println(super.getName() + "吃火锅、烧烤、串串香");
}
}
四,抽象方法与抽象类的深入
public class Test02 {
/**
* 知识点：深入抽象类及抽象方法
*
* 面试题：
1.抽象类中只能有抽象方法？
不是
分析：抽象类中可以有什么？
属性、构造方法、成员方法、静态方法、抽象方法
2.抽象类中不可以没有抽象方法？
错的，抽象类可以没有抽象方法，但是毫无意义
3.如果父类是抽象类，则子类必须实现父类的抽象方法？
不一定，如果子类是抽象类，可以不实现父类的抽象方法
4.抽象类不能有构造方法？
错的
5.可以使用new关键字来创建抽象类对象？
不可以！！！抽象类不能创建对象
*/
public static void main(String[] args) {
//创建的是匿名内部类的对象
Person person = new Person() {
@Override
public void eat() {
System.out.println("印度人吃咖喱");
}
};
person.eat();
}
}
五,接口
理解：
接口是引用数据类型的一种，接口是特殊的抽象类，接口中只能有静态常量和抽象方法JDK1.8开始接口中允许有默认方法和静态方法- 应用场景：接口相当于制作大纲
- 注意：
1.接口中的方法默认添加public abstract2.接口中的属性默认添加public static final- 需求：设计学生管理系统的接口
- 分析：
管理系统 -- 管理一个一个的学生对象（涉及到学生类）怎么管理？增删改查
//c测试类
public class Test01 {
public static void main(String[] args) {
StudentManagerSystemImpl sms = new StudentManagerSystemImpl();
sms.add(new Student("徐灿", '男', 23, "2308", "001"));
sms.defaultMethod();
IStudentManagerSystem.staticMethod();
}
}
定义接口
public interface IStudentManagerSystem {
//修改学生信息的常量
int NAME = 1;
int SEX = 2;
int AGE = 3;
int CLASS_ID = 4;
int ID = 5;
/**
* 添加学生
* @param stu
* @return
*/
public int add(Student stu);
/**
* 扩容
*/
public void expansion();
/**
* 删除学生
* @param classId
* @param id
* @return
*/
public int delete(String classId,String id);
/**
* 查询学生下标
* @param classId
* @param id
* @return
*/
public int queryIndex(String classId,String id);
/**
* 查询学生对象
* @param classId
* @param id
* @return
*/
public Student query(String classId,String id);
default void defaultMethod(){
System.out.println("默认方法");
}
public static void staticMethod(){
System.out.println("静态方法");
}
}
实现接口
// 实现类 实现 接口
public class StudentManagerSystemImpl implements IStudentManagerSystem{
@Override
public int add(Student stu) {
System.out.println("添加学生");
return 0;
}
@Override
public void expansion() {
// TODO Auto-generated method stub
}
@Override
public int delete(String classId, String id) {
// TODO Auto-generated method stub
return 0;
}
@Override
public int queryIndex(String classId, String id) {
// TODO Auto-generated method stub
return 0;
}
@Override
public Student query(String classId, String id) {
// TODO Auto-generated method stub
return null;
}
}
学生类
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) {
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;
}
}
六,接口的深入
面试题：
1.一个类可以实现多个接口？
可以
2.一个接口可以实现多个接口？
不可以
3.接口里面的方法不一定都是抽象的？
JDK1.8之前：接口中只能有静态常量和抽象方法
JDK1.8开始：接口中允许使用默认方法和静态方法
4.接口解决了类的单继承问题？
解决了 5.一个类是否可以继承一个类并同时实现多个接口？
可以 6.接口可以new对象？
不可以，创建的是匿名内部类的对象 类-类的关系：单继承
类-接口的关系：多实现
接口-接口的关系：多继承
//测试类
public class Test01 {
public static void main(String[] args) {
I1 i1 = new I1() {
@Override
public void i1Method() {
System.out.println("用良心做教育");
}
};
i1.i1Method();
}
}
//单继承,多实现
public class A extends B implements I1,I2,I3{
@Override
public void i2Method() {
// TODO Auto-generated method stub
}
@Override
public void i1Method() {
// TODO Auto-generated method stub
}
@Override
public void i4Method() {
// TODO Auto-generated method stub
}
@Override
public void i5Method() {
// TODO Auto-generated method stub
}
@Override
public void i3Method() {
// TODO Auto-generated method stub
}
}
//父类B
public class B {
}
public interface I1 {
//接口i1
public void i1Method();
}
//接口i2
public interface I2 {
public void i2Method();
}
//接口i3继承i4,i5
public interface I3 extends I4,I5{
public void i3Method();
}
//接口i4
public interface I4 {
public void i4Method();
}
//接口i5
public interface I5 {
public void i5Method();
}