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判断是否是该类的对象。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
