文章目录

一、Object
二、final
三、抽象类及抽象方法
四、接口

一、Object

含义：所有类的超类/基类

理解：如果一个类没有明确继承某个类，默认继承Obejct类

equals：判断两个对象的内存地址是否一样

Object o1 = new Object();
Object o2 = new Object();System.out.println(o1.equals(o2));
System.out.println(o1 == o2);

getClass：获取该类的字节码文件对象

Object o1 = new Object();
Object o2 = new Object();Class<? extends Object> c1 = o1.getClass();//获取Object类的字节码文件对象
Class<? extends Object> c2 = o2.getClass();//获取Object类的字节码文件对象System.out.println(c1.equals(c2));
System.out.println(c1 == c2);

hashCode：获取对象的hash值
注意：hash值不代表内存地址，其实是内存地址+散列算法获取到的一个数字

Object o1 = new Object();
Object o2 = new Object();System.out.println(o1.hashCode());
System.out.println(o2.hashCode());

toString：返回对象的字符串表示（把对象转换为字符串）
注意：Integer.toHexString(hashCode()) --> 把10进制的hash值转换为16进制

 public String toString(){return getClass().getName() + "@" + Integer.toHexString(hashCode());}

Object o1 = new Object();//java.lang.Object@15db9742
System.out.println(o1);//默认调用toString
System.out.println(o1.toString());

作用：起到所有类的表率，不同的子类去重写即可

equals：判断两个对象是否相等，不同的子类有不同的判断标准，所有子类重写即可

toString：返回对象的字符串表示，不同的子类有不同的表示方式，所以子类重写即可

getClass：获取字节码文件的对象，用于反射

  理解Object的标杆作用equals标杆作用：判断两个对象是否相同不同的子类有不同判断标准，所以子类重写父类的equals方法即可toString标杆作用：获取对象的字符串表示

Student类

package com.dream.test02;public class Student {private String name;private int age;private char sex;private String classId;private String id;public Student() {}public Student(String name, int age, char sex, String classId, String id) {this.name = name;this.age = age;this.sex = sex;this.classId = classId;this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}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;}//重写父类的equals后//判断两个学生对象是否相同：判断班级号+学号@Overridepublic 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;}@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", classId=" + classId + ", id=" + id + "]";}
}

测试类

package com.dream.test02;public class Test01 {public static void main(String[] args) {/*** 理解Object的标杆作用* * equals标杆作用：判断两个对象是否相同*    不同的子类有不同判断标准，所以子类重写父类的equals方法即可* * toString标杆作用：获取对象的字符串表示*/Student stu1 = new Student("大牛", 18, '男', "2101", "001");Student stu2 = new Student("大牛", 18, '男', "2101", "001");System.out.println(stu1.equals(stu2));//trueSystem.out.println(stu1 == stu2);//falseSystem.out.println(stu1);System.out.println(stu2);}}

理解Object类的标杆作用
User类

package com.dream.test03;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;}@Overridepublic boolean equals(Object obj) {if(this == obj){return true;}User u = (User) obj;if(this.username.equals(u.username)){return true;}return false;}@Overridepublic String toString() {return "User [username=" + username + ", password=" + password + ", name=" + name + "]";}}

测试类

package com.dream.test03;public class Test01 {public static void main(String[] args) {/*** 理解Object类的标杆作用*/User u1 = new User("1445584980", "123123", "掌握梦想");User u2 = new User("1445584980", "321311", "千锋Java何老师");System.out.println(u1.equals(u2));System.out.println(u1);System.out.println(u2);}}

深入Object

 理解String底层Object -- equals：判断两个对象内存地址是否相同String -- equals：判断两个字符串内容是否相等String的equals是判断的两个字符串内容是否相等，原理是将字符串转换为字符数组，依次取出字符，判断两个字符的ASCII是否相等

MyString类

package com.dream.test04;public class MyString {private String s;public MyString(String s) {this.s = s;}@Overridepublic boolean equals(Object obj) {if(this == obj){return true;}MyString m = (MyString) obj;//把两个对象的字符串转换为字符数组char[] v1 = this.s.toCharArray();//['a','b','c']char[] v2 = m.s.toCharArray();//['a','b','c']if(v1.length != v2.length){return false;}for (int i = 0; i < v1.length; i++) {if(v1[i] != v2[i]){//判断字符是否相等（判断的ASCII）return false;}}return true;}@Overridepublic String toString() {return this.s;}}

测试类

package com.dream.test04;public class Test01 {public static void main(String[] args) {/*** 深入Object* * 理解String底层* * Object -- equals：判断两个对象内存地址是否相同* String -- equals：判断两个字符串内容是否相等* * String的equals是判断的两个字符串内容是否相等，原理是将字符串转换为字符数组，依次取出字符，判断两个字符的ASCII是否相等*/String str1 = new String("abc");String str2 = new String("abc");System.out.println(str1.equals(str2));//trueSystem.out.println(str1 == str2);//falseSystem.out.println(str1);//abcSystem.out.println(str2);//abcSystem.out.println("--------");MyString m1 = new MyString("abc");MyString m2 = new MyString("abc");System.out.println(m1.equals(m2));//trueSystem.out.println(m1 == m2);//falseSystem.out.println(m1);System.out.println(m2);}}

二、final

含义：最终的

作用：

修饰变量：常量（不可变的量，使用全大写命名，单词与单词之间用下划线隔开）

修饰方法：方法不能被重写

修饰类：类不能被继承
A类

package com.dream.test05;//该类为最终的类，不能被继承
public final class A {//准备阶段：int i ;//准备阶段：int i = 10;public final static int I = 10;//子类不能重写该方法public final void method(){System.out.println("父类的方法");}}

B类

package com.dream.test05;//public class B extends A{public class B{}

测试类

package com.dream.test05;public class Test01 {public static void main(String[] args) {/*** final：最终的* * 作用：*       1.修饰变量：常量*       2.修饰方法：方法不能被重写*      3.修饰类：类不能被继承*/final int i = 10;System.out.println(i);}}

三、抽象类及抽象方法

抽象方法：

语法：访问修饰符 abstract 返回值类型方法名([参数]);

含义：交给非抽象的子类去实现(重写)

注意：

1.没有代码块

2.抽象方法一定是在抽象类

应用场景:当该方法不能很好的实现时，将该方法设置成抽象的，交给非抽象的子类去实现

抽象类：

语法：访问修饰符 abstract class 类名{}

需求：编写中国人和日本人
Person类

package com.dream.test06;//抽象类
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 abstract void hobby();public void sleep(){System.out.println(this.name + "睡觉觉");}}

Japanese类

package com.dream.test06;public class Japanese extends Person{private String japaneseId;public Japanese() {}public Japanese(String name, char sex, int age, String japaneseId) {super(name, sex, age);this.japaneseId = japaneseId;}public String getJapaneseId() {return japaneseId;}public void setJapaneseId(String japaneseId) {this.japaneseId = japaneseId;}@Overridepublic void eat() {System.out.println(super.getName() + "吃马赛克");}@Overridepublic void hobby() {System.out.println(super.getName() + "喜欢拍电影");}}

Chinese类

package com.dream.test06;public abstract class Chinese extends Person{private String chineseId;public Chinese() {}public Chinese(String name, char sex, int age, String chineseId) {super(name, sex, age);this.chineseId = chineseId;}public String getChineseId() {return chineseId;}public void setChineseId(String chineseId) {this.chineseId = chineseId;}public abstract void dialect();
}

GuangDong类

package com.dream.test06;public class GuangDong extends Chinese{public GuangDong() {}public GuangDong(String name, char sex, int age, String chineseId) {super(name, sex, age, chineseId);}@Overridepublic void dialect() {System.out.println(super.getName() + "说闽南语、粤语");}@Overridepublic void eat() {System.out.println(super.getName() + "吃肠粉、海鲜粥、八合里潮汕牛肉火锅");}@Overridepublic void hobby() {System.out.println(super.getName() + "喜欢喝茶、收租");}}

SiChuan类

package com.dream.test06;public class SiChuan extends Chinese{public SiChuan() {}public SiChuan(String name, char sex, int age, String chineseId) {super(name, sex, age, chineseId);}@Overridepublic void dialect() {System.out.println(super.getName() + "说四川话");}@Overridepublic void eat() {System.out.println(super.getName() + "吃火锅");}@Overridepublic void hobby() {System.out.println(super.getName() + "打麻将");}}

测试类

package com.dream.test06;public class Test01 {public static void main(String[] args) {/*** 抽象类和抽象方法* * 需求：编写中国人和日本人*/Japanese j = new Japanese("古川伊织", '女', 23, "6969696969696969");j.eat();j.hobby();SiChuan sc = new SiChuan("大牛", '男', 18, "123456789");sc.eat();sc.hobby();sc.dialect();GuangDong gd = new GuangDong("李嘉诚", '男', 70, "987654321");gd.eat();gd.hobby();gd.dialect();}}

深入-面试题：

1.可以使用new关键字来创建抽象类对象？

不能，创建的是匿名内部类的对象

2.抽象类中只能有抽象方法？

抽象类可以有非抽象的方法

3.抽象类中不可以没有抽象方法？

可以没有抽象方法，但是这样就毫无意义
4.抽象方法必须在抽象类里吗？

必须

5.如果父类是抽象类，则子类必须实现父类的抽象方法？

不一定，子类如果是抽象类，可以不实现父类的抽象方法

6.抽象类不能有构造方法？

可以有构造方法的
7.既然抽象类不能创建对象，那拿构造方法有什么用？

子类可以通过父类的构造方法给父类的属性赋值

Chinese类

package com.dream.test07;public abstract class Chinese extends Person{private String chineseId;public Chinese() {}public Chinese(String name, char sex, int age, String chineseId) {super(name, sex, age);this.chineseId = chineseId;}public String getChineseId() {return chineseId;}public void setChineseId(String chineseId) {this.chineseId = chineseId;}public abstract void dialect();
}

测试类

package com.dream.test07;public class Test01 {public static void main(String[] args) {/*** 深入抽象类和抽象方法    //创建匿名内部类的对象//1.创建匿名类，继承Chinese类，重写父类的抽象方法//2.创建匿名类的对象Chinese chinese = new Chinese() {@Overridepublic void hobby() {}@Overridepublic void eat() {}@Overridepublic void dialect() {}};}}

四、接口

含义：特殊的抽象类

注意：接口中只能有静态常量和抽象方法；JDK1.8开始，接口中可以有默认方法和静态方法

接口应用场景：跟抽象类比，接口更像一个规范，规定了实现类应该要去实现哪个方法
应用场景：抽象类只有静态常量或抽象方法，就用接口去代替

深入接口 - 面试体：
1.一个类可以实现多个接口？
可以实现多个接口：public 类名 implements 接口1,接口2{}
2.一个接口可以实现多个接口？
不可以，一个接口可以继承多个接口
3.接口里面的方法不一定都是抽象的？
JDK1.8开始接口中可以有默认方法和静态方法，JDK1.8之前除了抽象方法外不能有其他方法
4.接口解决了类的单继承问题？
对的，一个类只能继承另一个类，但是可以实现多个接口
5.一个类是否可以继承一个类并同时实现多个接口？
可以
6.接口可以new对象？
不可以，接口是特殊的抽象类，抽象类都不可以，接口自然就不可以，new 接口是创建的匿名内部类的对象

类 – 接口的关系：

类与类：单继承

类与接口：单实现、多实现

接口与接口：多继承、多层继承

需求：编写中国人和日本人

IPerson接口

package com.dream.test08;public interface IPerson {//抽象方法：默认添加public abstractpublic void eat();//抽象方法：默认添加public abstractpublic void hobby();//JDK1.8新特性：接口中的默认方法default void sleep(){System.out.println("睡觉觉");}//JDK1.8新特性：接口中的静态方法public static void destination(){System.out.println("人类生活在地球~~~");}}

Chinese实现类

package com.dream.test08;public abstract class Chinese implements IPerson{private String name;private char sex;private int age;public Chinese() {}public Chinese(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 dialect();}

Japanese实现类

package com.dream.test08;//              实现类     实现        接口
public class Japanese implements IPerson {private String name;private char sex;private int age;private String japaneseId;public Japanese() {}public Japanese(String name, char sex, int age, String japaneseId) {this.name = name;this.sex = sex;this.age = age;this.japaneseId = japaneseId;}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 getJapaneseId() {return japaneseId;}public void setJapaneseId(String japaneseId) {this.japaneseId = japaneseId;}@Overridepublic void eat() {System.out.println(this.name + "吃马赛克");}@Overridepublic void hobby() {System.out.println(this.name + "拍电影");}}

GuangDong类

package com.dream.test08;public class GuangDong extends Chinese{public GuangDong(String name, char sex, int age) {super(name, sex, age);}@Overridepublic void eat() {System.out.println(super.getName() + "吃肠粉");}@Overridepublic void hobby() {System.out.println(super.getName() + "喝茶、收租");}@Overridepublic void dialect() {System.out.println(super.getName() + "说闽南话、粤语");}}

SiChuan类

package com.dream.test08;public class SiChuan extends Chinese{public SiChuan(String name, char sex, int age) {super(name, sex, age);}@Overridepublic void eat() {System.out.println(super.getName() + "吃火锅");}@Overridepublic void hobby() {System.out.println(super.getName() + "打麻将");}@Overridepublic void dialect() {System.out.println(super.getName() + "说四川话");}}

测试类

package com.dream.test08;public class Test01 {public static void main(String[] args) {/*** 接口：特殊的抽象类* * 需求：编写中国人和日本人* * 应用场景：抽象类只有静态常量或抽象方法，就用接口去代替*/Japanese j = new Japanese("小西满里惠", '女', 29, "123456789");j.eat();j.hobby();j.sleep();SiChuan sc = new SiChuan("大牛", '男', 23);sc.eat();sc.hobby();sc.dialect();sc.sleep();GuangDong gd = new GuangDong("李嘉诚", '男', 70);gd.eat();gd.hobby();gd.dialect();gd.sleep();IPerson.destination();}}

深入接口

注意：
- 1.两个接口中有同名的方法，只会实现一个方法
- 面试题：
  1. 一个类可以实现多个接口？
    可以
  2. 一个接口可以实现多个接口？
    不行
  3. 接口里面的方法不一定都是抽象的？
    JDK1.8之前接口中只能有静态常量和抽象方法
    JDK1.8开始接口中可以有默认方法和静态方法
  4. 接口解决了类的单继承问题？
    对的
  5. 一个类是否可以继承一个类并同时实现多个接口？
    可以
  6. 接口可以new对象？
    不可以
    
    类与接口的关系：
    类与类：单继承
    类与接口：多实现
    接口与接口：多继承

I1接口

package com.dream.test09;public interface I1 {public void i1Method();public void method1();public void method2();}

I2接口

package com.dream.test09;public interface I2 {public void i2Method();public void method1();default void method2(){System.out.println("I2中的默认方法");}
}

I3接口

package com.dream.test09;public interface I3 extends I4,I5{public void i3Method();}

I4接口

package com.dream.test09;public interface I4 {public void i4Method();}

I5接口

package com.dream.test09;public interface I5 {public void i5Method();}

A类

package com.dream.test09;//          子类   继承         父类          实现       多个接口
public class A extends Object implements I1,I2,I3{@Overridepublic void i2Method() {}@Overridepublic void i1Method() {}@Overridepublic void i4Method() {}@Overridepublic void i3Method() {}@Overridepublic void i5Method() {}@Overridepublic void method1() {}//实现I1中的抽象方法@Overridepublic void method2() {// TODO Auto-generated method stub}//重写I2中的默认方法
//  @Override
//  public void method2() {//      //调用I2接口中的默认方法
//      I2.super.method2();
//  }}

测试类

package com.dream.test09;public class Test01 {public static void main(String[] args) {//创建匿名内部类的对象//1.创建匿名类，实现I1接口中的抽象方法//2.创建匿名类的对象I1 i1 = new I1() {@Overridepublic void method2() {}@Overridepublic void method1() {}@Overridepublic void i1Method() {}};}}

Day11-面向对象（4)相关推荐

编程中的英语单词大全
学习Java中用到的专业术语单词总结 day1 掌握 1.JDK abbr. Java开发工具包(Java Developer's Kit) (abbr.缩写) 2.JRE abbr. Java运行环 ...
一般英文(java)
day1 Java概述掌握 1.JDK abbr. Java开发工具包(Java Developer's Kit) (abbr.缩写) 2.JRE abbr. Java运行环境(Java Runti ...
Java相关英语单词
day1 Java概述掌握 1.JDK abbr. Java开发工具包(Java Developer's Kit) (abbr.缩写) 2.JRE abbr. Java运行环境(Java Runti ...
python 100days github_GitHub - songhp/Python-100-Days: Python - 100天从新手到大师
Python教学大纲 Python应用领域和就业形势分析简单的说,Python是一个"优雅"."明确"."简单"的编程语言. 学习曲线低, ...
【Java语言基础】面向对象之封装、继承、抽象类、接口、多态综合知识习题及总结day11
这几天逐渐被idea所折服,越来越喜欢这个优雅又强大的代码编辑器,有很多人说idea对很多初学者不友好,但是在我看来,只要你足够自律,并且英语不会太差,语法上关键的几个单词没什么大问题,idea对初学 ...
Java学习日记Day11（面向对象day05）
面向对象第5天: 回顾: 向上造型:--------------代码复用超类型的引用指向派生类的对象能点出来什么,看引用的类型------------------这是规定方法的重写(overri ...
python学习面向对象Day11（P116~~126）
b站达内python课学习笔记 P116 Python面向对象–3.1 课程回顾一.day10复习 """day10 复习类和对象类:抽象向量 class Vecto ...
day11 Java 面向对象 final 多态
文章目录一.final 关键字二.多态 (polymorphic) 1.基本 2.多态访问成员特点 3.向上转型和向下转型 3.instanceof 关键字 4.多态访问成员特点五.练习总结 ...
python 之路，Day11 (下)- sqlalchemy ORM
python 之路,Day11 - sqlalchemy ORM 本节内容 ORM介绍 sqlalchemy安装 sqlalchemy基本使用多外键关联多对多关系表结构设计作业 1. ORM介绍 ...
Java面向对象学习练习———潜艇游戏（飞机游戏）
潜艇游戏需求: 所参与的角色: 战舰.深水炸弹.侦察潜艇.鱼雷潜艇.水雷潜艇.水雷角色间的关系: 战舰发射深水炸弹深水炸弹可以打潜艇(侦察潜艇.鱼雷潜艇.水雷潜艇),若打中: 潜艇消失.深水炸弹消 ...

Day11-面向对象（4)