继承：在Java中，继承是描述类与类之间的关系。(父子)
特点：1.子类可以访问父类中所有非私有的成员，父类不可以访问子类成员。（子类可以找父类，父类不能找子类）
2.子类要加载，要先加载父类。（先有的爹后有的儿子）
3.单一继承，多层继承。（一个儿子只有一个亲爹，但是爹还有爹）
4.子类知道自己的父类是谁，但是父类不知道子类。（从继承格式体现）
注意：Java中任何一个类如果在没有继承的情况下，都是默认继承于Object类
Object是：基类，超类，根类。（炎黄）
Java中所有类都是直接或者间接继承于Object类
1.2继承的格式
extends:生产 ---> 继承 子类的定义格式：（继承的声明在子类上，子类知道自己父类是谁） public class 子类名 extends 父类名{ } 父类的定义格式：（父类不知道，哪些子类继承了它） --->段正淳 public class 父类名称{ } 学习技巧：从子类出发，将子类中的共性成员进行向上抽取，再利用继承关系来访问这些成员。1.3继承关系下成员的访问特点：
在继承关系前提下，访问子类成员： 1.当子类有该成员，则优先访问子类成员，子类没有找父类要，如果所有的父类都没有，那就报错！！ 总结：优先级：子类 > 父类1.4 继承关系下构造方法的访问特点
1.当调用子类构造方法时，当方法中没有申明调用父类构造方法时，系统会默认在子类构造方法的第一行提供一个super();
2.当子类中调用了父类的构造方法时，系统就不提供super();
3.super：本类父类对象的引用。 （亲子鉴定）
public class Die {
int age;
String name;
public Die() {
System.out.println("父类无参构造");
}
public Die(int age, String name) {
this.age = age;
this.name = name;
System.out.println("父类有参构造");
}
}
class Zai extends Die{
int age;
String name;
public Zai() {
super();//在子类的构造方法中如果没有任何调用父类构造方法的语句，就会在子类构造方法的第一行默认super();
System.out.println("子类无参构造");
}
public Zai(int age, String name) { // this口诀：哪一个对象调用了this所在的方法，this就代表那一个对象
//super(); super:本类对象的父引用 亲自鉴定 super口诀：哪一个对象调用了super所在的方法，super就代表那一个对象的父对象
//super(age,name);
this.age = age;
this.name = name;
System.out.println("子类有参构造");
}
}
class Test2{
public static void main(String[] args) {
Zai zai = new Zai();
Zai zai2 = new Zai(35,"段正淳");
}
}
1.Zai zai : 先找到Zai类，发现Zai继承了Die，所以先加载Die类，再加载Zai类（只有类加载后才能创建对象）
2.new Zai（）：先找到Zai类无参构造方法执行。
因为Zai类的无参构造方法中没有任何调用父类构造方法的语句，所以在第一行会默认有super()；1.5方法重写：
方法重载：overload
在同一个类中，方法名相同，形式参数列表不同（个数，类型，顺序不同），与返回值无关。
方法重写：override
1.类与类之间要有继承或者实现关系.
2.子类和父类中方法的申明完全一致
2.1权限修饰符：public > protected > default(不写) > private
2.2子类中重写的方法的权限修饰符 >= 父类中该方法的权限修饰符
2.3父类中被重写的方法的权限修饰符不能是privater
@Override:如果一个方法上加了这个注解，说明这个方法是重写的方法。
作用：限定子类重写的方法和父类中被重写的方法格式完全一致
public void eat(){
System.out.println("抽烟，喝酒");
}
@Override
public void eat(){
System.out.println("喝牛奶");
}
1.6super和this关键字
super:本类父类对象的引用 -- 哪个对象调用了super所在的方法super就是哪个对象的父类对象的引用. (亲子鉴定)
this:本类对象的引用. -- 哪个对象调用了this所在的方法,this就是哪个对象. (照镜子)
注意：1.super和this不是真实的对象，只是对象的引用。
2.super和this只存在与事物描述类中。
3.super和this不能存在于static修饰的方法中.
总结：哪个对象调用了this所在的方法，this就代表哪个对象
哪个对象调用了super所在的方法，super就代表哪个对象的父对象
this.变量名：强制指向本类成员变量
this.方法名：强制指向本类成员方法
this(): 本类无参构造
this(实际参数)：本类有参构造
super.变量名：强制指向父类成员变量.
super.方法名：强制指向父类成员方法.
super(): 本类父类对象的无参构造
super(实际参数)：本类父类对象的有参构造
变量优先级： 局部变量 > 本类成员变量 > 父类成员变量
2.final关键字
final :最终的, 没有后代的 , 被阉割的.
类:有子类继承该类,代表有后代 --> 被final修饰的类不能被继承.
方法:该方法被重写,代表有后代 --> 被final修饰的方法不能被重写
变量:该变量可以被重新赋值,代表有后代 --> 被final修饰的变量是自定义常量,其值无法被改变
Arrays工具类：
工具类的特点:
1.工具类中会提供一个私有的无参构造方法,目的是不能去创建工具类对象.
2.工具类中的成员方法都是静态的,可以使用类名直接调用.
例如:Arrays.toString() , Arrays.sort()
3.Object类
Object是所有类的根类 --->(炎黄)
当一个类没有写任何继承关系时，默认继承Object类
3.1.getclass()方法： 类的字节码对象
Object obj = new Object();
Class clazz= obj.getClass();
System.out.println(clazz);//java.lang.Object 包名+类名
3.2 toString()方法：
package com.powernode.bean.demo2;
import com.powernode.bean.demo1.Student;
public class ObjectDemo1 {
public static void main(String[] args) {
Object obj = new Object();
Class clazz = obj.getClass();
System.out.println(clazz);//java.lang.Object 包名+类名
Student stu = new Student();
Class aClass = stu.getClass();
System.out.println(aClass);//class com.powernode.bean.demo1.Student 包名+类名 == 全类名
System.out.println(stu.hashCode());//1163157884 stu对象在堆内存中的十进制地址
System.out.println(stu.toString());//com.powernode.bean.demo1.Student@4554617c
}
}
3.3equals()
public class ObjectDemo3 {
public static void main(String[] args) {
Student stu1 = new Student("暴强","河北");
Student stu2 = new Student("暴强","河北");
System.out.println(stu1.equals(stu2));
}
}
class Student extends Object{
String name;
String address;
public Student(String name,String address) {
this.name = name;
this.address = address;
}
@Override
public boolean equals(Object obj ) { //stu2
Student stu = (Student) obj; //stu = stu2
return this.name.equals(stu.name) && this.address.equals(stu.address); //this = stu1
}
}
3.4 hashCode()
System.out.println(stu.hashCode());//1163157884 stu对象在堆内存中的十进制地址3.5 定义事物描述类：
1.成员变量
2.构造方法
3.setter() and getter()
4.成员方法
5.重写toString() --->打印对象的内容
6.重写hashCode() --->能够判断两个对象地址和内容是否都相同
7.重写equals()
package com.powernode.test;
import java.util.Objects;
public class Demo1 {
}
class Teacher{
//1.成员变量
private String name;
private int age;
//2.构造方法
public Teacher() {
}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
//3.setter() and getter()
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;
}
//4.重写equals() 和 hashCode()
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Teacher teacher = (Teacher) o;
return age == teacher.age &&
Objects.equals(name, teacher.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//5.重写toString()
@Override
public String toString() {
return "Teacher{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
//6. 成员方法
public void sleep(){
System.out.println("睡觉");
}
}
4.脑图
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）