1. 父子类构造方法
子类没有通过super调用父类的有参构造，也没有this调用本类的有参构造，那么系统默认调用
父类的无参构造方法
如果调用了父类的有参构造，将不再调用无参构造方法
子类必须调用父类的有参或者无参构造方法其中一个
，默认调无参
package com.edu.test1;
/**
* 父类
* 父类中编写子类共有的属性 和 方法
*/
public class Pet {
private String name;
private int health;
private int love;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
public void print() {
System.out.println("宠物的名字是：" + name + "，健康值是：" + health + "，爱心值是：" + love );
}
public Pet() {
System.out.println("父类Pet类的无参构造执行了");
}
public Pet(String name, int health, int love) {
System.out.println("父类Pet类的全参构造方法");
this.name = name;
this.health = health;
this.love = love;
}
}
package com.edu.test1;
/**
* Dog类
* 品种
* print()
*
* 子类没有通过super调用父类的有参构造，也没有this调用本类的有参构造，那么系统默认调用
* 父类的无参构造方法
* 如果调用了父类的有参构造，将不再调用无参构造方法
*
* 子类必须调用父类的有参或者无参构造方法其中一个，默认调无参
*/
public class Dog extends Pet{
private String strain;
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public Dog() {
System.out.println("子类Dog类的无参构造执行了");
}
public Dog(String strain) {
this.strain = strain;
}
public Dog(String strain,String name,int health,int love) {
// super(name, health, love);
this.strain = strain;
}
}
package com.edu.test1;
/**
* 企鹅类
* 性别
* print()
*/
public class Penguin extends Pet{
private String sex;
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Penguin() {}
}
package com.edu.test1;
/**
* 测试类
*
*
*/
public class TestPet {
public static void main(String[] args) {
Dog dog = new Dog();
System.out.println("----------------------------------");
Dog dog1 = new Dog("金毛");
System.out.println("----------------------------------");
Dog dog2 = new Dog("金毛", "大黄", 100, 100);
}
}
2.不能继承哪些内容
3.可以继承哪些内容
继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里 继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里
4. 方法重写
方法重写规则 1.父子类之间
2.方法名相同
3.参数列表相同
4.返回值类型相同 或者是其子类
5.访问权限不能严于父类(不能窄化父类的访问权限)
6.不能抛出比父类更多的异常
7.静态方法可以被继承，但是不能被重写
package com.edu.test3;
/**
* 父类
* 父类中编写子类共有的属性 和 方法
*/
public class Pet {
private String name;
private int health;
private int love;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
void print() {
System.out.println("宠物的名字是：" + name + "，健康值是：" + health + "，爱心值是：" + love );
}
}
package com.edu.test3;
/**
* Dog类
* 品种
* print()
*/
public class Dog extends Pet{
private String strain;
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public Dog() {}
/**
* 方法重写规则
* 1.父子类之间
* 2.方法名相同
* 3.参数列表相同
* 4.返回值类型相同 或者是其子类
* 5.访问权限不能严于父类(不能窄化父类的访问权限)
*
* 6.不能抛出比父类更多的异常
* 7.静态方法可以被继承，但是不能被重写
*/
public void print() {
super.print();
System.out.println("狗狗的品种是：" + strain);
}
}
package com.edu.test3;
/**
* 企鹅类
* 性别
* print()
*/
public class Penguin extends Pet{
private String sex;
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Penguin() {}
public void print() {
super.print();
System.out.println("企鹅的性别是：" + sex);
}
}
package com.edu.test3;
/**
* 测试类
*/
public class TestPet {
public static void main(String[] args) {
Penguin penguin = new Penguin();
penguin.print();
Dog dog = new Dog();
dog.print();
}
}
5. @Override注解
@Override注解可以加在子类的方法上，表示重写父类的方法，如果没有正确重写，则编译报错
6.方法重写和方法重载的区别？
方法重写：Override
方法重载：Overload
7. Object类
Object类是所有的类父类。我们可以重写此类中的方法实现我们的个性化操作。
8. 重写toString()
Object类的toString方法默认是返回当前对象的全限定名(包名 + 类名)+@+hash值，我们可以根据自己的需求进行重写，我们直接打印一个对象将默认调用此对象的toString方法
实际开发中，通常都会写为返回当前对象的属性名 + 属性值
package com.edu.test5;
/**
* 学生类
* 名字
* 年龄
* 性别
* 爱好
*
* 我们重写toString方法的目的是为了在我们直接输出一个对象的时候
* 不再打印包名类名+hash值，而是打印属性名+属性值，因为这样我们查看对象的信息更便捷
*/
public class Student {
private String name;
private int age;
private String sex;
private String hobby;
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public String toString() {
return "Student[name = " + name + ",age=" + age + ",sex = " + sex + ",hobby = " + hobby + "]";
}
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("赵四");
stu1.setAge(20);
stu1.setSex("男");
stu1.setHobby("尬舞");
System.out.println(stu1.getName());
System.out.println(stu1.getAge());
System.out.println(stu1.getSex());
System.out.println(stu1.getHobby());
System.out.println(stu1.toString());
// 直接打印某个对象 将默认调用此对象的toString方法
System.out.println(stu1);
}
}
9. 重写equals()
==和equals的区别？
==比较基本数据类型比较值 ， 比较引用数据类型比较内存中的地址
equals本身也比较地址，但是我们可以重写按照我们指定的规则来比较
String类就是对equals方法进行了重写，将原本 父类的比较地址重写为了比较内容
package com.edu.test6;
/**
* 人类
* 名字
* 身份证号
*
* ==和equals的区别？
* ==比较基本数据类型比较值 ， 比较引用数据类型比较内存中的地址
* equals本身也比较地址，但是我们可以重写按照我们指定的规则来比较
* String类就是对equals方法进行了重写，将原本 父类的比较地址重写为了比较内容
*/
public class Person {
private String name;
private String idCard;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIdCard() {
return idCard;
}
public void setIdCard(String idCard) {
this.idCard = idCard;
}
public Person(String name, String idCard) {
this.name = name;
this.idCard = idCard;
}
public Person() {
}
public static void main(String[] args) {
Person p1 = new Person("赵四", "5612157843213265632323");
Person p2 = new Person("赵四", "5612157843213265632323");
System.out.println(p1 == p2); // ==比较基本数据类型比较值 比较引用数据类型比较地址
System.out.println(p1.equals(p2)); // 比较内存中的地址是否相同
System.out.println("---------------------------------------------------");
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2); // false
System.out.println(str1.equals(str2));// true
}
}
自己模拟equals方法 实现字符串比较
String类equals方法比较规则：
1.先比较地址，如果地址相同则直接返回true
2.如果地址不同，再将两个字符串转换为char数组，然后对应位置的元素进行比较
package com.edu.test6;
/**
* 自己模拟equals方法 实现字符串比较
* String类equals方法比较规则：
* 1.先比较地址，如果地址相同则直接返回true
* 2.如果地址不同，再将两个字符串转换为char数组，然后对应位置的元素进行比较
*
*/
public class MyString {
public static void main(String[] args) {
String str1 = "abcdefg";
char [] ch1 = str1.toCharArray();
for (int i = 0; i < ch1.length; i++) {
System.out.print(ch1[i] + "\t");
}
System.out.println();
System.out.println("--------------------------------");
System.out.println(myEquals("abcd", "abc"));
}
public static boolean myEquals(String str1,String str2) {
char [] ch1 = str1.toCharArray();
char [] ch2 = str2.toCharArray();
if(ch1.length != ch2.length) {
return false;
}
for(int i = 0;i < ch1.length;i++) {
if(ch1[i] != ch2[i]) {
return false;
}
}
return true;
}
}
版权声明：本文为qq_44768841原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。