二、Java面向对象特征

Java SE复习总目录
本人情况说明：20年春学过Java语言，了解简单语法，但并不会应用，面向对象的特征及堆栈的概念也并不清楚，希望这个假期可以进行总体的回顾，并通过记博客的方式督促自己，巩固知识，欢迎有相同目标的小伙伴共同交流，一起进步鸭~~

---

---

前言

Java面向对象的三大基本特征(封装、继承、多态)：本章主要对这三大特征进行简要介绍。

---

一、类和对象

1.什么是类

1. Java程序的最小程序单位是类，整个Java程序是由一个一个的类组成。
2. 类包含两部分:
 数据→属性/成员变量
 对数据的操作→方法。
3. 方法定义不能嵌套；方法只能定义在类中。
4. 使用new通过类生成对象。

public class Text {
    public static void main(String[] args) {
        Person person=new Person();//生成对象，必须在main方法里
    }
}
class Person
{
    //类的属性和方法
}

4. return；表示什么也不返回，当程序运行到该语句时，退出该方法，即不再执行该语句后面的语句。
5. 类与方法的命名: 类名中的每个单词首字母大写，如MemberTest。
 方法名首个单词全小写，以后每个单词首字母大写，如addThreeInt 属性名与方法名相同，例age，ageOfPerson。

2.局部变量与成员变量

1. 定义在类里的变量叫成员变量，定义在方法里的变量叫局部变量。
2. 使用.来使用类的属性。
3. 局部变量使用前必须要声明并赋初值，成员变量使用前必须要声明，可以不赋初值（有默认初始值:byte,int short long为0，float,double为0.0，char为'\u0000'，boolean为false）。

public class Text {
    int a;//成员变量，可以不赋初值
    public void method()
    {
        int b = 0;//定义在方法里，是局部变量，必须赋初值
        System.out.println(b);
    }

    public static void main(String[] args) {
        Text text=new Text();//main方法需先生成对象，再进行对类的操作
        System.out.println(text.a);
        text.method();
    }
}

3.什么是对象

1. 在Java语言中除八个基本数据类型值之外，一切都是对象。而对象就是面向对象程序设计的中心。
2. Java中无法直接操纵对象，都是通过引用来对对象进行操作， Peaple people = new people()；中people为引用，new people ()为对象，对象在堆中，而引用在栈中，多个引用可指向一个对象，通过一个引用改变对象，其他引用也随之改变。
3. 类中的每一个对象有各自的属性，但共享一个方法。

public class Text {
    int a;
    public void method()
    {
        int b = 0;
        System.out.println(b);
    }

    public static void main(String[] args) {
        Text text1=new Text();
        Text text2=new Text();
        text1.a=1;//对象1有其自己的成员变量a=1
        text2.a=2;//对象2有其自己的成员变量a=2
        System.out.println(text1.a);
        System.out.println(text2.a);
        text1.method();
        text2.method();//对象1和对象2共用一个方法method，均输出0
    }
}

1
2
0
0

3. 引用的类型和对象的类型相同。

Text t=new Text();//t是引用，不是对象，new Text()生成一个对象

4. new关键字生成对象时:为对象开辟内存空间→调用类的构造方法→将生成的对象的地址返回。
5. 将一个引用赋值给另一个引用相当于创建了一个指向该对象的新引用，即此时有两个引用指向同一对象；而几个new就表示有几个对象，new对应的引用指向各自不同的对象。

public class Text {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println(person1.age);//输出20
        Person person2 =person1;//person2和person1指向同一个对象，一个改变也影响另一个。
        person2.change(person2);
        System.out.println(person1.age);//输出18
        System.out.println(person2.age);//输出18
    }
}
class Person
{
    int age = 20;
    public void change(Person person1)
    {
        age=18;
    }
}

20
18
18

public class Text {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println(person1.age);//输出20
        Person person3 = new Person();//person3和person1指向不同对象，一个改变不影响另一个。
        person3.change(person3);
        System.out.println(person1.age);//输出20
        System.out.println(person3.age);//输出18
    }
}
class Person
{
    int age = 20;
    public void change(Person person1)
    {
        age=18;
    }
}

20
20
18

6. instanceof: 判断一个对象是否是某个类的实例，格式为

引用名  instanceof  类名（接口名）

返回一个boolean值；注意子类就是父类，子类的引用 instanceof 父类也返回true。

4.方法参数与方法重载

1. 构造方法用于完成对象属性的初始化工作，其名字与类名相同，且无返回值（即访问修饰符直接跟方法名，void表示返回空，也算作有返回值），若类中未定义，则默认隐式定义一个方法体为空的构造方法。

class A
{
    public A()
    {
        //可手动编写，默认为空
    }
}

class A  //未定义构造方法的类，默认为空，同上，不可见
{
}

2. 调用构造方法传递参数，形参表示又创建了一个指向该对象的新引用。
以上面的代码为例，此时有

3. 方法重载表示同一个类内部两个或多个方法名字相同，但参数不同（个数或类型不同），注意，方法的返回值对重载没有任何影响。

public class Text
{
    public static void main(String[] args) {
        Person zhangsan = new Person();
        zhangsan.change();
        System.out.println("----------------------");
        zhangsan.change(20);

    }
}
class Person
{
    public void change(){

    }
    public int change(int age){
        System.out.println(age);
        return age;
    }
}

----------------------
20

4. 构造方法的重载:只需看参数即可，若想在一个构造方法中调用另一个构造方法，使用this()，他必须作为该构造方法的第一条语句。

public class Text
{
    public static void main(String[] args)
    {
        Person zhangsan = new Person();
        Person lisi = new Person(20);
    }
}
class Person
{
    public Person()
    {
        System.out.println("无参构造");
    }
    public Person(int age)
    {
        System.out.println("有参构造");
    }

}

无参构造
有参构造

public class Text
{
    public static void main(String[] args)
    {
        Person zhangsan = new Person();
    }
}
class Person
{
    public Person()
    {
        this(20);
        System.out.println();//一个构造方法使用this调用重载的另一个构造方法，注意this语句要放在第一位
    }
    public Person(int age)
    {
        System.out.println("年龄为"+age);
    }
}

年龄为20

二、封装

1. 封装的概念：利用访问权限修饰符将某个类的代码和数据包装、隐藏起来，作为一个保护屏障防止被修改，然后通过一些公用方法来暴露该对象的功能。
2. 访问控制修饰符：
  私有的——private(封装部分多用其来修饰)
  默认的——不使用任何修饰符
  受保护的——protected
  公开的——public

3. Java程序源文件的文件名必须与public类的类名相同，因此，一个Java源文件里最多只能定义一个public类。

4. private方法是私有的，不能new。

三、继承

1.继承的概念

1. 继承是面向对象实现软件复用的重要手段，当子类继承父类后，子类作为一种特殊的父类，将直接获得父类的属性和方法。
2. Java是单继承，即一个类只有一个父类，（但可以实现多个接口，关于接口的概念见第三章）执行时先执行父类的构造方法（不带参数），生成父类的对象，再执行子类的构造方法（不带参数），再生成子类的对象；若父类无不带参数的构造方法，须在子类中使用super(参数)来调用，若有，使用super就会去调用带参数的，而忽略不带参数的，super与this一样，也必须作为构造方法的第一条语句。

public class Text
{
    public static void main(String[] args)
    {
        Rose rose = new Rose();
    }
}
class Flower
{
    public  Flower(){
        System.out.println("这里有一朵花");
    }
}
class Rose extends Flower
{
    public  Rose(){
        System.out.println("这里有一朵玫瑰花");
    }
}

这里有一朵花
这里有一朵玫瑰花

public class Text
{
    public static void main(String[] args)
    {
        Rose rose = new Rose();
    }
}
class Flower
{
    public  Flower(){
        System.out.println("这里有一朵花");
    }
    public  Flower(int size){
        System.out.println("这里有一朵直径为5cm的花");
    }
}
class Rose extends Flower
{
    public  Rose(){
        super(5);
        System.out.println("这里有一朵玫瑰花");
    }
}

这里有一朵直径为5cm的花
这里有一朵玫瑰花

2. 方法和属性可以被继承，构造方法不能被继承(子类仅仅执行但并不继承，它有自己的构造方法)。

2.方法重写

1. 方法重写（@Override）用于继承，子类和父类的方法类型名称，参数都相同。
2. super.重写的方法名()可以同时调用子类和父类的重写方法，此时super语句不一定要放在第一行。

public class Text
{
    public static void main(String[] args)
    {
        Rose rose = new Rose();
        rose.size();
    }
}
class Flower
{
    public void size(){
        System.out.println(6);
    }

}
class Rose extends Flower
{
    public void size(){
        super.size();
        System.out.println(4);
    }
}

6
4

3. 注意区分方法重载和方法重写，重载指类中同名的两方法，根据参数的不同，编译器自动进行调用；重载是子类对父类方法的改写。

四、多态

4. 多态是指:父类型的引用可以指向子类的对象，但运行时依然表现出子类的行为特征，这意味着同一类型的对象在执行同一个方法是可能表现出多种行为特征，例 Flower rose=new rose();
5. 多态中调用的方法必须同时在父类和子类中出现。
6. 多态中父类型的引用可强制转换成子类型。

Flower rose1 = new Rose();
Rose rose = (Rose) rose1;

7. 多态的应用:同一父类下的多个子类实现一个功能时，只用父类中的一个方法即可完成，注意该方法的参数为父类。

class Car
{
	public void run (Car car)  
	{     
		car.run();      
	}
}
//之后可定义多种类表示各种具体汽车，再在这些类下实现（重写）各车独有的run方法