Java三大特征

Java三大特征

记录自己每次学习的成果

一. 封装

该露的露，该藏的藏
我们程序设计要追求 “高内聚，低耦合” 。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
封装(数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了:属性私有，get/set

例如：

public class Student extends Person {
    private String name;
    private int age;

    public void speak(){
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

二. 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
Java中类只有单继承，没有多继承!
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系。
在idea中，按ctrl+H 打开层次结构。

重点：

object类
super
方法重写

1. 继承的特性

• 子类拥有父类非 private 的属性、方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

2.Object类

所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。（后续多线程讲解）

3. super关键字

• super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

实例1：

import com.mnm.oop.demo01.Student;
public class Application {
    public static void main(String[] args) {
        Student student =new Student();
        student.test("Application");
    }
}

//子类
public class Student extends Person {
    private String name="Student";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

//父类
public class Person {
    protected String name="Person";
}

//执行结果：
Application
Student
Person

实例2：

import com.mnm.oop.demo01.Student;
public class Application {
    public static void main(String[] args) {
        Student student =new Student();
        student.test();
    }
}

//子类
public class Student extends Person {
    public void print(){
        System.out.println("Student");
    }
    public void test(){
        print();
        this.print();
        super.print();
    }
}

//父类
public class Person {
    public void print(){
        System.out.println("Person");
    }
}

//执行结果：
Student
Student
Person

实例3：

import com.mnm.oop.demo01.Student;
public class Application {
    public static void main(String[] args) {
        Student student =new Student();
    }
}

//子类
public class Student extends Person {
    public Student() {
    	//隐藏代码
        //默认调用了父类的无参构造
        //super();调用父类的构造器，必须在子类构造器第一行
        System.out.println("Student无参构造执行了");
    }
}

//父类
public class Person {
    public Person() {
        System.out.println("Person无参构造执行了");
    }
}

//执行结果：
Person无参构造执行了
Student无参构造执行了

实例总结：

super注意点:
	1. super调用父类的构造方法，必须在构造方法的第一个
	2. super必须只能出现在子类的方法或者构造方法中
	3. super和this不能同时调用构造方法
和 this 相比
	1. 代表的对象不同
			this ：本身调用者这个对象
			super：代表父类对象的引用
	2. 前提
			this：没有继承也可以使用
			super：只能在继承的条件下使用
	3. 构造方法
			this()：本类的构造
			super()：父类的构造

4.方法重写

实例1：

import com.mnm.oop.demo01.A;
import com.mnm.oop.demo01.B;
public class Application {
    public static void main(String[] args) {
        A a = new A();
        B b = new A();
        a.test();
        b.test();
    }
}

public class A extends B{
    public static void test(){
        System.out.println("A=>test");
    }
}

public class B {
    public static void test(){
        System.out.println("B=>test");
    }
}

//运行结果：
A=>test
B=>test

实例2：

import com.mnm.oop.demo01.A;
import com.mnm.oop.demo01.B;
public class Application {
    public static void main(String[] args) {
        A a = new A();
        B b = new A();
        a.test();
        b.test();
    }
}

public class A extends B{
    public void test(){
        System.out.println("A=>test");
    }
}

public class B {
    public void test(){
        System.out.println("B=>test");
    }
}

//运行结果：
A=>test
A=>test

两者对比后得出的结论：

静态的方法和非静态的方法差距很大
静态方法：方法的调用只和左边定义的数据类型有关
非静态方法：子类重写了父类的方法

方法重写的规则

• 参数列表与被重写方法的参数列表必须完全相同。

• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

• 父类的成员方法只能被它的子类重写。

• 声明为 final 的方法不能被重写。

• 声明为 static 的方法不能被重写，但是能够被再次声明。

• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

• 构造方法不能被重写。

• 如果不能继承一个类，则不能重写该类的方法。

三. 多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
有继承关系
子类重写父类方法，父类引用指向子类对象
注意:多态是方法的多态，属性没有多态性。
重点：
instanceof

1. 实例：

import com.mnm.oop.demo01.Person;
import com.mnm.oop.demo01.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        Person student1 = new Student();
        Object student2 = new Student();
        student.run();
        student1.run();
        student.eat();
    }
}

public class Person {
    public void run(){
        System.out.println("person run");
    }
}

public class Student extends Person {
    public void run(){
        System.out.println("student run");
    }
    public void eat(){
        System.out.println("student eat");
    }
}

//执行结果：
student run
student run
student eat

2. 多态的注意事项

多态是方法的多态，属性没有多态
父类和子类必须有联系，否则类型转换异常：ClassCastException
存在的条件：继承关系，方法重写，父类引用指向子类