java入门-----面向对象（三）

面向对象

继承

使用场景：多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类

好处：减少了代码的冗余

深入继承：

创建子类对象，会不会调用父类构造方法？
会
创建子类对象，会不会创建父类对象？
不会
创建子类对象，为什么会调用父类构造方法？
目的是将父类的属性存放在子类对象中

创建子类对象，先调用父类构造方法还是子类构造方法？
先调用子类构造方法

创建子类对象，先完成父类构造方法还是子类构造方法？
先完成父类构造方法

子类可以继承父类私有化的属性和方法吗？

​ 可以，但是只能间接调用

super - 父类

含义：代表父类

作用 在子类中：

1. super.属性：调用父类非私有化的成员变量
2. super.方法：调用父类非私有化的成员方法
3. super()：调用父类非私有化的构造方法

重写

含义：重写也叫做复写，将父类中方法在子类中重新编写一遍

应用场景：父类方法不满足子类需求时，子类就可以重复父类的方法

条件：

1. 在子类中重写父类的方法
2. 返回值、方法名和参数列表必须和父类重写的方法一致
3. 访问修饰符不能比父类重写的方法更严格

package Test02;

public class Test {
	public static void main(String[] args) {
		Chinese c = new Chinese();
		c.setName("张三丰");
		c.setChinaId("123456789");//中国身份证
		c.eat();

		Japanese j = new Japanese();
		j.setName("亚索");
		j.setYearNumber("令和");//日本年号
		j.eat();
	}
}

张三丰吃满汉全席
亚索吃生鱼片

package Test02;

public class Chinese extends Preson {//中国人,继承人类属性
	private String ChinaId;//添加父类没有的属性
	public String getChinaId() {
		return ChinaId;
	}
	public void setChinaId(String chinaId) {
		ChinaId = chinaId;
	}
	public void eat() {
		System.out.println(super.getName()+"吃满汉全席");//重写 ；super调用父类的getName
	}
}

package Test02;

public class Japanese extends Preson {//日本人
	private String  yearNumber;//添加父类没有的属性
	public String getYearNumber() {
		return yearNumber;
	}
	public void setYearNumber(String yearNumber) {
		this.yearNumber = yearNumber;
	}
	public void eat() {
		System.out.println(super.getName()+"吃生鱼片");//重写 ；super调用父类的getN
	}
}

package Test02;

public class Preson {//人类
	private String name;
	public Preson() {}
	public Preson(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void eat() {
		System.out.println(this.name+"吃饭饭");
	}
}

访问修饰符

含义：修饰类、方法、属性，定义使用的范围

学习：做实验

访问修饰符	本类	本包	其他包子类	其他包
private	OK
默认的	OK	OK
protected	OK	OK	OK
public	Ok	OK	OK	Ok

Object

含义：基类也叫做超类，Object是所有类的祖先类

注意：如果一个类没有明确继承的父类，默认继承Object

equals：比较两个对象内存地址是否相同

hashCode：获取对象的hash值

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

toString：获取对象的字符串表示

package com.Xu.Test;

public class Test01 {
	@SuppressWarnings("unlikely-arg-type")
	public static void main(String[] args) {
		Animal animal = new Animal();
		Person person = new Person();
		//获取对象的字符串表示
		System.out.println(animal.toString());
		//比较两个对象内存地址是否相同
		System.out.println(person.equals(animal));
		//获取对象的hash值
		System.out.println(person.hashCode());
		//获取类的字节码文件对象
		System.out.println(person.getClass());
	}
}

package com.Xu.Test;

public class Animal {
	private String name;
	private String varieties;//品种
	private int age;//年龄
	public Animal() {
		// TODO Auto-generated constructor stub
	}
	public Animal(String name, String varieties, int age) {
		super();
		this.name = name;
		this.varieties = varieties;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getVarieties() {
		return varieties;
	}
	public void setVarieties(String varieties) {
		this.varieties = varieties;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃东西 ");
	}
	public void sleep() {
		System.out.println(name+"睡觉");
	}
}

package com.Xu.Test;

public class Person {
	private String name;
	private char sex;//性别
	private int age;//年龄
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, char sex, int age) {
		super();
		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 void eat() {
		System.out.println(name+"吃东西 ");
	}
	public void sleep() {
		System.out.println(name+"睡觉");
	}
}

标杆作用：Object作为所有类的父类，定义了几个方法，方便子类去重写

equals的标杆作用：比较两个对象是否相同，不同的对象比较规则不一样，所以子类重写即可

toString的标杆作用：每个子类都有不同的属性，重写toString直接打印该对象中所有的属性，方便观察数据

final

含义：最终

作用：

1. 修饰类：该类不能被继承

2. 修饰方法：该方法不能被重写

3. 修饰变量：变成常量，不能重新赋值

   ​ 常量的命名规则：全大写，单词之间用下划线隔开

   ​ 常量的声明周期：存在常量池中，直到项目结束才会被销毁

抽象类及抽象方法

//抽象类
public abstract class 类名{
    //抽象方法
    public abstract void method();
}

抽象方法交给非抽象的子类去实现(重写)

应用场景：当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现

package com.Xu.work;

public abstract class Person {//定义一个抽象类，用abstract修饰
	String name;
	public abstract void eat();//抽象方法，没有方法体，有abstract关键字做修饰
	public abstract void sleep();
}

package com.Xu.work;

public class A extends Person {
	@Override
	public void eat() {//抽象方法必须重写
		System.out.println(super.name+"用盆吃饭");
	}
	@Override
	public void sleep() {
		System.out.println(super.name+"站着睡觉");
	}

}

package com.Xu.work;

public class Test {
	public static void main(String[] args) {
		A a = new A();
		a.name="小明";
		a.sleep();
		a.eat();
	}
}

小明站着睡觉
小明用盆吃饭

接口

含义：特殊的抽象类

注意：

1. JDK1.7时，接口中只能有静态常量和抽象方法
2. JDK1.8开始，接口中有静态常量和抽象方法和默认方法

应用场景：接口更像一个规范

抽象类 vs 接口

抽象类：成员变量、静态变量、静态常量、成员方法、静态方法

接口：静态常量、静态方法、默认方法(JDK1.8)

package com.Xu.Test02;

public interface A {
	final int a=1;
	public abstract void eat();
}

package com.Xu.Test02;

public interface B {
	final int b=2;
	public abstract void sleep();
}

package com.Xu.Test02;

public class AB implements A,B{
	//必须重写接口的所有抽象方法 
	@Override
	public void sleep() {
		System.out.println("睡觉觉");
	}
	@Override
	public void eat() {
		System.out.println("吃饭饭");
	}
}

package com.Xu.Test02;

public class Test {
	public static void main(String[] args) {
		AB ab = new AB();
		ab.eat();
		ab.sleep();
		System.out.println(ab.a);
		System.out.println(ab.b);
	}
}

吃饭饭
睡觉觉
1
2

类 - 接口的关系：
类 - 类：单继承
类 - 接口：多实现
接口 - 接口：多继承

创作不易，每天更新优质内容，各位路过给个关注。。。