JavaSE——类和对象（上）

1、面向过程和面向对象

人把大象放进冰箱

1. 面向过程：强调功能行为，以函数为最小单位，考虑怎么做。

1、打开门
2、放大象
3、关门

2. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

人：打开冰箱、放大象、关闭冰箱
冰箱：被打开、关闭
大象：被放

2、类和对象

2.1、属性

属性和局部变量的区别

1. 定义的位置不同
2. 权限修饰符不同：属性有private/protected/public/缺省。局部变量不能有修饰符。
3. 默认初始化值得情况：属性都有默认初始值（字符是0或‘\u0000’）.。局部变量没有初始化值。
4. 内存中加载的位置不同：属性加载到堆空间中。局部变量放在栈空间中。

属性的赋值过程

1. 默认初始化
2. 显示初始化
3. 构造器中初始化
4. 通过”对象.属性“或”对象.方法“的方法赋值

2.2、方法

1. 方法的重载：方法名字相同，参数个数不同
2. 可变个数形参方法：

public void show(String ... strs){
		system.out.println("你传几个String类型的参数都可以(0个都可以)");
		for(int i=0;i<strs.length;i++){
				System,out.println(str[i]);//还是将其当成数组遍历
		}
}
/*
public void show(String[] strs){
}//这两者不能共存

public void show(int x,String ... strs){
}//可变个数形参方法只能写在后面，写在前面分不清给他分配几个。
*/

3. 方法参数的值传递机制

如果是基本数据类型，此时赋值保留原有数据；如果是引用数据类型，此时赋值是变量所保存的数据地址值。

char[] a=new char[]{'a','b','c'};
System.out.println(a);//abc
String[] b=new String[]{"d","e","f"};
System.out.println(b);//地址值

2.3、构造器

1. 构造器的作用：创建对象、初始化属性
   说明：
   1、一个类中定义多个构造器，彼此构成重载。
   2、一旦我们定义了构造器，系统不在提供默认构造器。
   3、默认构造器的权限是类的权限

3、面向对象的三大特征

3.1、封装

1. 封装性的特点

高内聚：类的内部数据操作细节已经完成，不允许外部干涉
低耦合：仅对外暴露少量的方法用于使用

2. 封装性的体现

封装性的体现:
1、将属性私有化，同时提供公共的方法获取(get)和设置(set)此值。
2、不对外暴露的私有化方法
3、单例方法

3. 权限修饰符

private：
default（缺省）：
protected：
public“：
可以用来修饰属性、方法、构造器、内部类，修饰类的话只能使用缺省和public

总的来说，封装性就是通过四种权限修饰符类和类的内部结构体现它可见性的大小。

3.2、继承

1、一个类可以被多个子类继承
2、所有的类父类都是Object类
3、方法重写是指：子类继承父类的函数之后，想实现不同的功能进行改造
4、super的使用：因为子类会对父类的函数进行重写，所以为了可以使用父类同名的函数，需要加上super。

3.3、多态

1、多态是对象的多态性，父类的引用指向子类的对象
2、当调用子父类同名参数的方法时，实际执行的是子类重写父类的方法（实际上调用的还是父类的方法，只不过执行的时候执行的是子类重写的方法），并且只能调用父类里面已经定义的方法。
3、多态使用的前提：类的继承关系、方法的重写
4、多态性不适用于属性

public class test {
    public static void main(String[] args){
        test a = new test();
        a.fun(new dog());
        a.fun(new cat());
    }

    private void fun(Animal a){
        a.shout();
    }
}

class Animal{
    public void shout(){
        System.out.println("动物叫");
    }
}

class dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪");
    }
}

class cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵");
    }
}
//汪汪汪
//喵喵喵 

注意1
多态是运行时行为不是编译时行为
我们在编译期间，只能调用父类中声明的方法，但在运行期间，我们实际执行的是子类重写的方法，所以多态的使用也叫虚拟方法的调用。

//原因如下：如果能直接看出来执行的结果就说明是编译行为，如果看不出来就是执行时行为
import java.util.Random;

public class test {
    public static void main(String[] args){
        int k= new Random().nextInt(3);
        Animal a=fun(k);
        a.shout();
    }

    private static Animal fun(int a){
        switch (a){
            case 0:
                return new Animal();
            case 1:
                return new dog();
            default:
                return new cat();
        }
    }
}

class Animal{
    public void shout(){
        System.out.println("动物叫");
    }
}

class dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪");
    }
}

class cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵");
    }
}

注意2
当我们需要使用子类特有的方法时，需要向下转型

Animal a=new dog();
dog b=(dog) a;

使用如下语句防止类型转换失败

注意3

4、UML图