Java进阶总结4
1.继承
1.1继承的定义
/**
* 子类继承父类
* 可以继承父类公共属性和方法 如果是私有的不能继承
* 继承需要关键字 extends
* java只支持单继承（只有一个亲父亲）
* 子类可以拥有自己的特性
* */
1.2super
/**
* 子类
* super 可以访问父类的属性和方法
* super 只能存在在子类的方法中
* super 可以存在子类的构造方法中 用来调用父类的构造方法 必须放在构造方法的第一行Super();
* */
package day09;
/*
* 父类
* 存放子类公共的属性
* */
public class Person {
//公共属性
String name;
int age;
private int tel;//电话
protected String address;
public Person() {
System.out.println("父类默认构造方法");
}
public Person(String name) {
this();
System.out.println("父类中带参数的构造方法");
}
//方法
public void sleep() {
System.out.println(name+"\t\t"+age+"\t\t睡觉");
}
}
package day09;
public class Employee extends Person{
//属性
String hirDete;//入职时间
//子类中定义和父类相同的属性和方法
String name;
public void sleep() {
System.out.println("不能睡了");
}
//子类的构造方法
/**
* 初始化一个对象的时候 ，构造方法必须调用一次
* 1.如果子类的构造方法没有显示调用父类的构造方法，会默认执行默认的构造方法
* 2.如果显示（super）调用父类指定的构造方法，父类指定的构造方法会被执行一次
* */
public Employee() {
//显示调用父类构造方法
//super();//指定调用默认的构造方法
super("尊");//指定调用带参数的构造方法
System.out.println("子类默认的构造方法");
}
public Employee(String name) {
System.out.println("子类有参构造方法");
}
//行为
public void method1() {
//不使用super可以访问父类的成员
//子类和父类没有相同的属性和方法
System.out.println("name=="+this.name);//调用当前类
System.out.println("super name=="+super.name);//调用父类
super.sleep();
this.sleep();
}
}
package day09;
public class Student extends Person{
//属性
String sid;//学号
}
package day09;
/**
* 子类
* */
public class Teacher extends Person{
//属性
int level;//级别
}
package day09;
//测试类
public class TestDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//初始化一个Student对象 给对象赋值
Student stu=new Student();
stu.sid="001";
stu.name="熊大";
stu.age=22;
//stu.tel=112233;//父类的私有成员不能被访问
stu.sleep();
System.out.println(stu.sid);
//初始化一个Teacher对象 给对象赋值
Teacher tea=new Teacher();
tea.name="熊二";
tea.age=21;
tea.level=3;
tea.sleep();
System.out.println(tea.level);
//初始化一个Employeer对象 给对象赋值
Employee em=new Employee();
em.name="熊三";
em.age=19;
em.hirDete="2018";
em.sleep();
em.method1();
System.out.println(em.hirDete);
}
}
输出结果：
1.3测试继承范围
package day09.qy;
import day09.Person;
/**
* 继承不同包的父类
* */
public class Worker extends Person{
public void dowork() {
//子类是否可以访问父类的private 、default（默认成员）、protected 、public
//this.tel=21;//私有成员不可直接访问
//this.name="尊";//默认成员在不同包中也不可访问
this.address="中国";//protected 修饰的成员可以在不同包的子类中访问
}
}
package day09.qy;
public class TestDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//初始化worker对象
Worker worker=new Worker();
//设置子类属性
//worker.name="尊";//使用的是默认权限修饰符，不能访问到
//worker.address="中国";//可以在不同包的子类中使用
}
}
输出结果：
1.4继承的练习题
package day09.Test1;
public class Animal {
private String name;//名字
private int age;
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 void doEat() {
System.out.println("吃东西");
}
//构造方法
public Animal() {
// TODO 自动生成的构造函数存根
System.out.println("父类默认构造方法");
}
public Animal(String name,int age) {
System.out.println("父类带参数构造方法");
//给父类属性赋值
this.name=name;
this.age=age;
}
}
package day09.Test1;
public class Cat extends Animal{
//设置子类特有属性
private String sex;
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//特有行为
public void upperTree() {
System.out.println("猫可以上树");
}
public Cat() {
// TODO 自动生成的构造函数存根
System.out.println("猫的默认构造方法");
}
public Cat(String name,int age) {
//调用父类带参数的构造方法 直接给父类属性赋值
super(name,age);
}
}
package day09.Test1;
public class Dog extends Animal{
//属性
private int weight;
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
//行为
public void swimming() {
System.out.println("狗会游泳");
}
public Dog() {
// TODO 自动生成的构造函数存根
}
public Dog(String name,int age) {
super(name,age);
}
}
package day09.Test1;
public class TestDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//初始化cat对象
Cat cat=new Cat("Tom",2);
//设置sex
cat.setSex("公");
//获取name和age属性
System.out.println(cat.getName());//子类没有找父类
System.out.println(cat.getAge());
System.out.println(cat.getSex());
//调用公共方法
cat.doEat();
//初始化dog对象
Dog dog=new Dog("ww", 4);
dog.setWeight(20);
System.out.println(dog.getName());
System.out.println(dog.getAge());
System.out.println(dog.getWeight());
dog.doEat();
dog.swimming();
}
}
输出结果：
1.5重写
/**
* 重写 只能是方法 只能重写父类的方法
* 当父类的功能满足不了子类特性， 子类需要对父类的方法重新定义
* 1.必须在子类中重写
* 2.方法名 参数列表必须一致
* 3.修饰符要嘛和父类一致，要嘛比父类修饰符权限大
* 4.子类方法的返回值类型是和父类方法的返回类型相同或者是其子类。
* 5.方法中声明的异常要么一致 要么获取子类类型
* */
package day09.Test2;
public class Animal {
private String name;//名字
private int age;
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 void doEat() {
System.out.println("吃东西");
}
//构造方法
public Animal() {
// TODO 自动生成的构造函数存根
System.out.println("父类默认构造方法");
}
public Animal(String name,int age) {
System.out.println("父类带参数构造方法");
//给父类属性赋值
this.name=name;
this.age=age;
}
}
package day09.Test2;
public class Cat extends Animal{
//设置子类特有属性
private String sex;
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//特有行为
public void upperTree() {
System.out.println("猫可以上树");
}
public Cat() {
// TODO 自动生成的构造函数存根
System.out.println("猫的默认构造方法");
}
public Cat(String name,int age) {
//调用父类带参数的构造方法 直接给父类属性赋值
super(name,age);
}
@Override //注解
public void doEat() {//重写父类方法
// TODO 自动生成的方法存根
//super.doEat();//调用父类的方法
System.out.println("猫吃鱼，喵喵喵");
}
}
package day09.Test2;
public class Dog extends Animal{
//属性
private int weight;
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
//行为
public void swimming() {
System.out.println("狗会游泳");
}
public Dog() {
// TODO 自动生成的构造函
}
public Dog(String name,int age) {
super(name,age);
}
@Override
public void doEat() {
// TODO 自动生成的方法存根
System.out.println("狗喜欢吃肉，汪汪汪");
//如果保留父类行为 可以使用super调用父类方法
super.doEat();
}
}
package day09.Test2;
public class TestDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//初始化cat对象
Cat cat=new Cat("Tom",2);
//设置sex
cat.setSex("公");
cat.doEat();
cat.upperTree();
//初始化dog对象
Dog dog=new Dog("ww", 4);
dog.setWeight(20);
dog.doEat();
dog.swimming();
}
}
输出结果：
1.6object类
| 方法 |
说明 |
| toString() |
返回当前对象本身的有关信息，按字符串对象返回 |
| equals() |
比较两个对象是否是同一个对象，是则返回true |
| hashCode() |
返回该对象的哈希代码值 |
| getClass() |
获取当前对象所属的类信息，返回Class对象 |
package day09.Test3;
public class Student {
//属性
String name;
int age;
//重写toString
@Override
public String toString() {
// TODO 自动生成的方法存根
return name+" "+age;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
//初始化student对象
Student stu=new Student();
Student stu1=stu;
System.out.println("stu=="+stu+"\nstu1=="+stu1);
//判断两个对象是否相等 恒等== 内存引用
if (stu.equals(stu1)) {
System.out.println("相等");
}else {
System.out.println("不相等");
}
//String 类型判断的是内容 其他类引用地址
String str=new String("123");
String str1=new String("1234");
if (str.equals(str1)) {
System.out.println("内容相等");
}else {
System.out.println("内容不相等");
}
stu.name="尊";
stu.age=21;
String msg=stu.toString();
System.out.println(msg);
}
}
输出结果：
1.7重写练习题
重写比较规则，判断两名学员（Student）是否为同一对象
Student相关属性：Id（学号）、name（姓名）、age（年龄）
如果两名学员的学号以及姓名相同，则为同一对象
package day09.Test4;
public class Student {
//设置属性
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
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;
}
@Override
public boolean equals(Object obj) {
Student stu=(Student)obj;
//instanceof用于判断一个引用类型所引用的对象是否是一个类的实例
if (stu instanceof Student) {
if(this.age==stu.getAge()&&this.name==stu.getName()&&this.id==stu.getId()){
return true;
}
}
return false;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Student stu1=new Student();
stu1.setId(1);
stu1.setName("尊");
stu1.setAge(21);
Student stu2=new Student();
stu2.setId(11);
stu2.setName("尊");
stu2.setAge(21);
if (stu1.equals(stu2)) {
System.out.println("是同一个人");
}else {
System.out.println("不是同一个人");
}
}
}
输出结果：
2.知识框架
