Java基础-面向对象上

了解

面向过程和面向对象

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

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

比如：把大象装进冰箱

面向过程：打开冰箱，把大象装进去，关冰箱门。

面向对象：

        人{

                打开（冰箱）{

                        冰箱.开门()

                }

                操作(){

        

                }

                关闭(){

                }

        }

        冰箱{

                开门(){}

                关门(){}

        }

把一系列的动作都写成类和方法实现。

面向对象中的两个重要概念

        类：对一类事物的描述，是抽象的，概念的

        对象：是类的实例化，是实际存在的

                面向对象程序设计的重点就是类的设计，设计类就是设计类的成员。

二者的关系

程序员经常调侃说，没对象怎么办，new一个出来。

对象就是由类new出来的。

面向对象的规则

1.创建类，设计类的成员

2.创建类的对象

3.通过对象.属性或对象.方法调用对象的结构

不同名称叫法：

属性=成员变量=field=域、字段

方法=成员方法=函数=method

创建类的对象=类的实例化=实例化类

对象的创建和对象的内存解析

Dog d = new Dog();

Dog d1 = new Dog();

Dog d2 =d;  这样的写法并没有新创建一个对象，只是共用一个堆空间中的对象实体。

如果创建了一个类的多个对象，每个对象都会有独立的属性和方法(static关键字修饰的除外)

修改一个对象的属性a,对另外一个对象的属性a不会造成影响(static关键字修饰的除外)

假设Dog类有个eat属性默认是吃肉。

把d对象的eat属性改为骨头。

d.eat="骨头";

输出d.eat 和d1.eat

System.out.println(d.eat);//骨头

System.out.println(d1.eat);// 肉

实例化对象，就会在堆空间中开辟一块空间，实例对象在栈区，指向这块开辟的空间，每个实例化都会开辟一块独立的空间，互不影响。

匿名对象

匿名对象：没取名的就叫匿名对象

写法：new 类名().属性或者.方法

 类的结构

1.属性

写法

权限修饰符 数据类型 变量名 = 变量值;

先声明后使用

调用方式

对象名.属性

2.方法

写法:权限修饰符 返回值类型 方法名(形参列表){
        方法体
        return 值;
     }

注意:
    默认方法的权限修饰符使用public
    返回值类型: 返回值 和没返回值
        如果有返回值 ，必须使用return 数据，且放在最后一行，【return;】: 表示结束该方法
        如果没有返回值:返回值类型用void 且不能使用return 但【return;】除外
    方法名要遵循表示符的规范和规则，要求见名知意
    形参列表，可以没有，也可以有多个,格式数据类型1 形参1,数据类型2 形参2,....
    方法体: 方法的功能实现
    方法的使用中，可以调用当前类的属性或方法
        方法A中又调用了方法A,这成为递归调用
方法的调用
    对象.方法名(实参)
当不知道形参个数是多少时，可以使用数据类型...参数的形式表示,叫可变个数形参
public void show(String...str){
    //获取形参
    for(int i= 0; i<str.length;i++){
        System.out.println(str[i]);
    }
}
调用: 对象.show("123","42234")也可以写成对象.show(new String[]{"aa","bb","ccc"})

return 关键字

使用范围:方法体内
作用: return; 结束方法
    return 数据; 返回数据
    return 在最后一行，也就说return下面不能有执行语句

 方法的重载

在同一个类中，允许出现多个同名方法，前提是，参数个数或参数类型不一致就行
    同一个类中，方法名相同
        参数列表不同，参数个数不同，参数类型不同
        
println()方法就是典型的重载，可以打印任何类型的数据
    println(int x)
    println(double d)
    println(String s)
    ....
方法重载的规则:
    1.在同一个类中
    2.方法名必须相同
    3.与权限修饰符无关
    4.与返回值无关
    5. 与形参列表(形参个数,形参顺序,形参类型)有关

 递归

递归:一个方法体内调用它自身
方法递归包含了一种隐世的循环，它会重复执行某段代码，但这种重复执行无序循环控制，但要加好判断条件，及时结束，要不然就成了无穷递归，类似死循环

面向对象的特征一：封装和隐藏

封装:将代码封装起来
隐藏:隐藏内部实现，只对外暴露方法名

 封装性的代码具体实现

1.使用者对类的内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题
2.可以把属性写成私有的，然后再写公共的set\get方法设置和获取属性

3.不对外暴漏私有的属性和方法

 封装性的目的

封装性的目的
    隐藏一个类中不需要对外提供的实现细节
    使用者只能通过事先定制好的方法来访问数据
    可以方便地加入控制逻辑，限制对属性的不合理操作
    便于修改，增强代码的可维护性

四种权限修饰符

注意

这四种权限修饰符都可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类只能用缺省和public，缺省就是不写修饰符。

public  class Xxx{}

class Xxx{}

3.构造器 

构造器的作用：创建对象，给对象初始化
    格式:权限修饰符 类名(形参列表){}
        1.定义多个构造器也可以称为重载
        2.一旦定义了类的构造器之后，系统就不再提供默认的空参构造器
        3.一个类中至少有一个构造器

this关键字

this可以用来修饰:属性、方法、构造器
this调用属性、方法
    this 当前对象或当前正在创建的对象
  在类的方法中，可以使用this.属性或this.方法的形式，调用当前对象属性或方法
  通常情况下，省略this，当方法的形参和属性同名是，为了区分，可以使用this.属性的方式调用属性
this调用构造器
     1.this(形参列表) 调用本类中指定的其他构造器
     2.构造器中不能通过this(形参列表)方式调用自己
     3.this(形参列表)必须放在当前构造器的(有效语句)的第一行
     4.构造器内部最多写一个this(形参列表)

 赋值的先后顺序

1.默认初始化
2.显式初始化/ 3在代码块中赋值(取决于先后位置)
4.构造器赋值
5.通过 “对象.方法”或“对象.属性”的方式赋值
  顺序 1 - 2 / 3 - 4-5

面向对象的特征二：继承性

为什么要有类的继承
    减少了代码的冗余，提高了代码的复用性
    便于功能的扩展
    为之后的多态，提供了前提
将几个类共有的属性和方法，提取到另一个类1，
这几个类都继承另一个类，提高代码的复用性
写法:
    class A extends B{}
        A: 子类、派生类、subclass
        B: 父类，超类、基类、superclass
注意:
    一旦子类A继承父类B后，子类A中就获取了父类B声明的所有的属性和方法,特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有化的结构。只因封装性的影响，使得子类不能直接调用父类的结构而已。
    子类继承父类以后，还可以声明自己特有的属性或方法:实现功能的拓展
        子类和父类的关系，不同于子集和集合的关系
    extends : 延展、扩展

Java中继承性的说明

1.一个类可以被多个子类继承
2.java类中类的单继承性: 一个类只能有一个父类，一个父类可以有多个子类
3.子父类是相对的概念
4.子类直接继承的父类，称为:直接父类，间接继承的父类称为:间接父类
5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性或方法
6.如果没有显式的声明一个类的父类，则此类继承java.lang.Object类
7.所有的java类都间接的继承java.lang.Object类(除了java.lang.Object这个类)，也就意味着，所有的java都具有java.lang.Object类声明的方法和属性

 方法的重写

重写:子类继承父类后，对父类的方法进行重写，也就是覆盖
创建子类对象后，调用子父类中的同名的同参数的方法时，实际执行的是子类重写父类的方法，(就近原则)
重写的规定:
    子类中的叫重写的方法，父类中的叫被重写的方法
    子类重写的方法的方法名和形参列表与父类中被重写的方法名和形参列表相同
    子类重写的方法的权限修饰符不能小于父类中被重写的方法的权限修饰符(大于或等于)
        特殊情况:若父类中被重写的权限修饰符是private则子类不构成重写
    返回值类型:
        父类中被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
        父类中被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型是相同的类型
        父类中被重写的返回值类型是引用类型，则子类重写的方法可以是引用类型的子类
            例 int ->  int
            例 Object-> String
    子类和父类中同名同参数的方法要么都声明为非static的(是重写)，要么都声明为static的(不是重写)
    因为static的方法属于类，子类无法覆盖

重载和重写区别

1方法的重写和重载是Java多态性的不同表现。
    1.1重写是父类与子类之间多态性的一种表现，
    1.2重载是一个类中多态性的一种表现。
2 如果在子类中定义某方法与其父类有相同的名称和参数，这就是重写
       子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。
3 如果在一个类中定义了多个同名的方法，
        它们或有不同的参数个数或有不同的参数类型，则称为方法的重载

 super关键字

1.super:可以理解为父类的
2.super可以调用属性、方法、构造器
3.super的使用:
    通常:在子类的方法或构造器中可以使用super.属性或super.方法的方式，显式的调用父类中声明的属性或方法，通常情况下可以省略super
    特殊情况:1.当子类和父类的属性相同时，要调用父类的属性，必须显式的使用super.属性的方式，表明调用的是父类中的属性
        2.当子类重写了父类中的方法以后，在子类的方法中调用父类中被重写的方法时，则必须显式的使用super.方法的方式，表明调用的是父类的被重写的方法
4.super调用构造器
    1.可以在子类的构造器中显式的使用super(形参列表)的方式调用父类中声明的指定的构造器
    2.super(形参列表)的使用,必须声明在子类构造器的首行
    3.this(形参列表)或super(形参列表)只能二选一
    4.在构造器中没有显式声明this(形参列表)或super(形参列表),则默认调用的是父类中空参构造
    5.在类的多个构造器中，至少有一个类的构造器使用了super(形参列表),调用父类中的构造器

本人是Java初学者，水平有限，本文章中如果有不对的地方，麻烦您能指出来。向您表示感谢。