Java基础复习(四):构造方法、封装、继承、多态
类和对象
Java是一种面向对象的语言,相较于面向过程的语言会更易扩展,易复用,易维护。
对象:对象是类的一个实例,有状态(属性)和行为(方法)。
类:类是一个模板,它描述一类对象的行为和状态。
类与对象之间是通过类中的构造方法联系的,对象的建立是通过new来实例化创建一个对象,调用类中的构造方法初始化对象。
构造方法
每个类都有构造方法,在创建该类的对象时,通过构造方法初始化对象。如果没有显式地为类定义构造方法,Java 编译器将会为该类提供一个默认无参构造方法。
构造方法特性:
- 构造方法的方法名必须与类名一致。
- 构造方法没有返回类型,但是不能用void声明构造方法,在方法名前面不用声明方法类型。
- 在使用构造方法生成类的对象时是自动执行,无需调用。
- 构造方法可以重载,以参数的个数,类型,或排序顺序区分。需要注意的是当我们自己添加构造方法后,编译器将不会提供默认的无参构造方法,所以就不能new一个对象但不传参数了,所以一般在重载构造方法后要重载一个无参构造。
面向对象三大特征
封装
封装是指把一个对象的状态信息(属性)隐藏在对象内部,不允许外部对象直接访问对象内部信息。
public class Student {
//封装一般步骤:
//1、私有化属性
private int id;
private String name;
//2、提供外界访问方法
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;
}
//3、重载构造方法,便于创建对象。
public Student(int id, String name) {
this.id = id;
this.name = name;
}
//一般都要创建无参构造方法,提高代码健壮性
public Student() {
}
}
this的使用:
- 当形参与成员变量重名时,如果在方法内部需要使用成员变量,必须添加this来表明该变量是类成员
- 在任意方法内,如果使用当前类的成员变量或成员方法可以在其前面添加this
- this可以作为一个类中,构造器相互调用的特殊格式
注意:在使用this调用本类中的其他构造器,要保证至少有一个构造器不是用this的,然后用this调用这个构造器。即不能出现构造器自己调用自己。
继承
- 子类拥有父类对象的所有属性和方法,包括私有属性和私有方法,但是父类中的私有属性和方法子类是无法访问的,不能调用,只能通过set、get方法访问;
- 一个子类不能有多个父类,只支持单继承,但可以多重继承;
- 子类可以拥有自己的属性和方法,即子类可以对父类进行发展;
- 子类可以用自己的方式实现父类的方法,重写;
继承关系中,父子类构造方法的访问特点:
- 子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类构造,后执行的子类构造;
- 子类构造可以通过super调用父类重载的构造方法;
- super的父类构造调用,必须是子类构造方法的第一语句,一个子类构造方法不能调用多次super构造;
举例分析:
public class Person {
private String name;
private String gender;
private int id;
public Person() {
System.out.println("Person无参构造方法");
}
public Person(String name, String gender, int id) {
this.name = name;
this.gender = gender;
this.id = id;
System.out.println("Person有参构造方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
public class Student extends Person{
public Student() {
System.out.println("Student无参构造方法");
}
public Student(String name, String gender, int id) {
super(name, gender, id);
System.out.println("Student有参构造方法");
}
}
public class Test {
public static void main(String[] args) {
Student student=new Student("zhangsan","nan",12);
System.out.println(student.getName());
System.out.println(student.getId());
System.out.println(student.getGender());
}
}
结果:
Person有参构造方法
Student有参构造方法
zhangsan
12
nan
从上面结果可以看出,当创建子类对象时,会通过 super(name, gender, id);
语句,先访问子类构造方法中调用的父类构造方法,再访问子类构造方法。
public class Student extends Person{
public Student() {
System.out.println("Student无参构造方法");
}
public Student(String name, String gender, int id) {
System.out.println("Student有参构造方法");
}
}
结果:
Person无参构造方法
Student有参构造方法
null
0
null
如果将子类Student的super(name, gender, id);
语句删除,则也会访问父类构造方法,但是访问的是父类的无参构造方法,原因就是子类构造方法当中有一个默认隐含的“super()”调用,所以也会访问父类的构造。
多态
多态,表示一个对象具有多种的状态。具体表现为父类的引用指向子类的实例。Java中有两种体现:一是方法的重载与重写;二是对象的多态,可以直接应用在抽象类和接口上。
1、重写与重载:
重写注意事项:
- 必须保证父子类之间名称相同,参数列表也相同。可以使用@Override写在方法前进行检测;
- 子类方法的返回值必须小于等于父类方法的返回值范围;
- 子类方法的权限必须大于等于父类方法的权限;
- 重写是在父类与子类之间;
//重写上面student类
public class Student extends Person{
public Student() {
System.out.println("Student无参构造方法");
}
public Student(String name, String gender, int id) {
super(name, gender, id);
System.out.println("Student有参构造方法");
}
@Override
public String getName() {
return "我是xxx学校的学生,我叫"+super.getName();
}
}
结果:
Person有参构造方法
Student有参构造方法
我是xxx学校的学生,我叫zhangsan
12
nan
重载注意事项:
- 必须保证重载方法之间名称相同,参数列表不相同。参数列表可以是个数的不同、数据类型的不同、顺序不同;
- 重写实在一个类中;
public class Overload {
public static void test(){
System.out.println("No parameters");
}
//添加参数的重载方法
public static void test(int a ){
System.out.println("a:"+a);
}
//改变参数类型的重载方法
public static void test(String b){
System.out.println("b:"+b);
}
//改变参数列表顺序的重载方法
public static void test(int c,String d){
System.out.println("c:"+c);
System.out.println("d:"+d);
}
public static void test(String d,int c){
System.out.println("d:"+d);
System.out.println("c:"+c);
}
public static void main(String[] args) {
test();
test(2);
test("3");
test(3,"4");
test("4",5);
}
}
结果:
No parameters
a:2
b:3
c:3
d:4
d:4
c:5
抽象类
抽象类和抽象方法(抽象方法只有方法声明,没有方法体,定义在抽象类中)必须用abstract关键字来修饰。
抽象类不可以被实例化,也就是不可以用new创建对象,只能通过继承来实现。
抽象类可以有构造方法、抽象方法和普通方法、静态方法等;抽象类中可以有变量;而在继承是抽象类时,子类必须实现抽象类的所有方法。
\\抽象类实例
public abstract class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Animal() {
}
public Animal(String name) {
this.name = name;
}
public abstract void run();
}
\\子类继承
public class Dog extends Animal{
public Dog() {
}
public Dog(String dogname) {
super.setName(dogname);
}
@Override
public void run() {
System.out.println(super.getName()+"在跑");
}
public static void main(String[] args) {
Dog dog = new Dog("小狗");
dog.run();
}
}
结果:小狗在跑
接口
接口中所有的方法都是没有方法体的,需要实现类自己实现;
接口中的所有变量都需要被public static final三个关键字一起修饰,不允许其他变量,其余都是常量;
注意事项:
1、 接口中不能有构造方法、静态代码块;
2、 一个类只能有一个父类(extends),但可以有多个接口(implements);
3、 如果实现类的所有接口有同名重复的抽象方法,只用重写一个;
4、 不能直接new接口对象,要new其实现类;
5、 如果实现类中没有重写覆盖接口中的抽象方法,则该实现类为抽象类;
6、 如果实现类的所有接口存在重复的默认方法,一定要对有冲突的默认方法进行重写;
7、 继承优先于接口;
\\接口实例
public interface Animal2 {
public void run();
}
\\实现类
public class DogImpl implements Animal2{
@Override
public void run() {
System.out.println("小狗再跑");
}
public static void main(String[] args) {
DogImpl dog = new DogImpl();
dog.run();
}
}
接口新特性:
1、早期版本(jdk7之前)中,接口里面只能有常量变量和抽象方法;
2、jdk8接口可以有默认方法和静态方法;
public interface TempI {
public abstract void div(int a, int b);
public default void
add(int a, int b)
{
System.out.print("Answer by Default method = ");
System.out.println(a + b);
}
public static void mul(int a, int b)
{
System.out.print("Answer by Static method = ");
System.out.println(a * b);
}
}
class Temp implements TempI {
@Override
public void div(int a, int b)
{
System.out.print("Answer by Abstract method = ");
System.out.println(a / b);
}
public static void main(String[] args)
{
TempI in = new Temp();
in.div(8, 2);
in.add(3, 1);
TempI.mul(4, 1);
}
}
结果:
Answer by Abstract method = 4
Answer by Default method = 4
Answer by Static method = 4
3、jdk9在接口中引入私有方法和私有静态方法。
public interface TempI {
public abstract void mul(int a, int b);
public default void add(int a, int b)
{
sub(a, b);
div(a, b);
System.out.print("Answer by Default method = ");
System.out.println(a + b);
}
public static void mod(int a, int b)
{
div(a, b); // static method inside other static method
System.out.print("Answer by Static method = ");
System.out.println(a % b);
}
private void sub(int a, int b)
{
System.out.print("Answer by Private method = ");
System.out.println(a - b);
}
private static void div(int a, int b)
{
System.out.print("Answer by Private static method = ");
System.out.println(a / b);
}
}
class Temp implements TempI {
@Override
public void mul(int a, int b)
{
System.out.print("Answer by Abstract method = ");
System.out.println(a * b);
}
public static void main(String[] args)
{
TempI in = new Temp();
in.mul(2, 3);
in.add(6, 2);
TempI.mod(5, 3);
}
}
结果:
Answer by Abstract method = 6 // mul(2, 3) = 2*3 = 6
Answer by Private method = 4 // sub(6, 2) = 6-2 = 4
Answer by Private static method = 3 // div(6, 2) = 6/2 = 3
Answer by Default method = 8 // add(6, 2) = 6+2 = 8
Answer by Private static method = 1 // div(5, 3) = 5/3 = 1
Answer by Static method = 2
对象的向上和向下转型
用instanceof
判断是否是该类的对象。