4.面向对象编程上

学习主线

1.Java类及类的成员：属性、方法、构造器；代码块、内部类

2.面向对象的三大特征：封装性、继承性、多态性（抽象性）

3.其他关键字：this、super、static、final、abstract、interface、package、import等

1.面向过程与面向对象

面向过程POP与面向对象OOP

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

例子：“人把大象装进冰箱”

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

1)把冰箱门打开

2）抬起大象，塞进冰箱

3）把冰箱门关闭

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

人{
    打开（冰箱）{
        冰箱.开开（）；
    }
    抬起（大象）{
        大象.进入（冰箱）；
    }
    关闭（冰箱）{
        冰箱.关关（）；
    }
}
冰箱{
    开开（）{}
    关关（）{}
}
大象{
    进入（冰箱）{}
}

2.两个要素：类和对象

1.概念

类（class）对一类事物的藐视，是抽象的、概念上的定义

对象（Object）实际存在的该类事物的每个个体，因而也称为实例（instance）

2设计类、其实就是设计类的成员

1.常见类的成员有：

属性field：对应类中的成员变量

行为method：对应类中的成员方法

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

2.使用：

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

2.创建类的对象

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

package zsbpackage;

public class PersonTest {
    public static void main(String[] args){
        //创建Person类的对象
        Person p1 = new Person();
        //调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        p1.name="Tom";
        p1.isMale =true;
        System.out.println(p1.name);
        System.out.println(p1.isMale);
        //调用方法：“对象.方法”
        p1.eat();
        p1.sleep();
        p1.talk("chinses");
    }
    static class Person{
        //属性field
        String name;
        int age;
        boolean isMale;
        //方法method
        public void eat(){
            System.out.println("人可以吃饭");
        }
        public void sleep(){
            System.out.println("人可以睡觉");
        }
        public void talk(String language){
            System.out.println("人可以说话，语言为"+language);
        }
    }
}

3.多个对象之间是相互独立的

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static的）意味着，如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值

        Person p2=new Person();
//        p2.name="joe";
        System.out.println(p2.name);

4.属性（成员变量）vs局部变量

1.相同点：

1）格式：数据类型 变量名 = 变量值

2）先声明，后使用

3）变量都有其对应的作用域

2.不同点：

1）在类中生命的位置不同

属性；直接定义在类的一对{}内

局部变量：生命在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2）权限修饰符不同

属性：可以在声明属性时，指明其权限，使用权限修饰符

常用的权限修饰符：private（私有） 、public、缺省、protected

局部变量：不可以使用权限修饰符

5.类中方法的声明和使用

方法：描述类应该具有的功能

比如：Math类：sqrt（）/random（）…

Scanner类：next（）…

Arrays类：sort（）/toString（）…

方法的声明：权限修饰符 返回值类型 方法名(形参列表){
    方法体
        }

说明：

1）权限修饰符：private（私有）、public、缺省、protected

2）返回值类型：有返回值vs没有返回值

​ 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时也需要return 数据；返回指定类型的数据

public String getNation(String nation){
    String info ="我的国籍:"+nation;
    System.out.println(info);
    return info;
}

​ 如果方法没有返回值，则方法声明时，使用void来表示。如果要用，return；来结束。

3）方法名：属于标识符“见名知意”

4）形参列表：方法可以生命0、1、多个形参。

格式：数据类型1 形参1，数据类型的2 形参2…

3.return关键字的使用：

1.使用范围：使用在方法体中

2.作用：结束语

​ 针对于有返回值类型的方法，return 数据；返回所要的数据

​ return后边不可以声明执行语句

4.方法的使用

可以调用当前类的属性或方法

特殊：方法A中又调用了方法A：递归调用

​ 方法中不可定义方法

5.匿名对象

创建的对象，没有显示的赋给一个变量名，即为匿名对象。

特征：匿名对象只能调用一次

6.方法的重载Overload

在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。

7.可变个数的形参

允许直接定义变量能和多个实参相匹配的形参

可变个数形参的格式：数据类型...变量名

当调用可变个数形参的方法时，传入的参数个数可以是0、1、2等

可变个数形参的方法与本类中的方法名相同，形参不同的方法之间构成。

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

方法：必须由其所在类或对象调用才有意义

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

9.递归方法

例题

计算1-n之间所有自然数的乘积：n！

public class PassObject {
    public static void main(String[] args) {
        int sum=getSum(5);
        System.out.println(sum);
    }

    public static int getSum(int n){
        if(n==1){
            return 1;
        }else{
            return n*getSum(n-1);
        }
    }
}

3.封装与隐藏

把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装的思想。

1.封装性的体现：

将类的属性私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值。

public class PassObject {
    public static void main(String[] args) {
        Animal a =new Animal();
        a.setlegs(4);
        System.out.println(a.getlegs());
    }

}
class Animal{
    //属性
    String name;
    int age;
    private int legs;
    //方法
    //对私有化属性的获取
    public int getlegs(){
        return legs;
    }
    //对私有化属性的设置
    public void setlegs(int a){
        legs=a;
    }
}

拓展：封装性的体现：①如上、②不对外暴露的私有的方法③单例模式。

2.封装的体现，需要权限修饰符来配合。

1.Java规定的4中权限（从小到大）：private、缺省、protected、public

2.4中权限都可以用来修饰类以及类的内部结构：属性、方法、构造器、内部类

4.构造器（构造方法constructor）

1.构造器的作用

创建对象

初始化属性

2.说明

①如果没有显示的定义类的构造器的话，系统默认空参的构造器

②定义构造器的格式：权限修饰符 类名（形参列表）{}

public class PersonTest {
    public static void main(String[] args) {
        //创建类的对象:new +构造器
        Person p =new Person();
        p.eat();
    }
}

class Person{
    //属性
    String name;
    int age;
    //构造器
    public Person(){
        System.out.println("hahah");
    }
    //方法
    public void eat(){
        System.out.println("吃饭");
    }
}

运行结果

3.定义多个构造器

public Person (String n){
    name =n;
}

Person p1=new Person("Tom");

一个类中定义的多个构造器，彼此构成重载

一旦我们显示了定义了类的构造器之后，系统就不在提供默认的空参构造器

一个类中，至少会有一个构造器

4.JavaBean

所谓Javabean,是符合一下标准的Java类：

​ >类是公开的

​ >有一个无参的公共的构造器

​ >有属性，且有对应的个体、set方法

5.关键字：this的使用

1.this可以用来修饰：属性、方法、贡藕早期

2.this修饰属性和方法：

​ this理解为：当前对象（你new的对象）

在类的方法（构造器也可以）中我们可以使用“this.属性”或“this.方法”的方式，调用当前对象的属性或方法，在一般情况下，我们选择省略“this”，如不省略则表明此变量是属性，而非形参。

3.this调用构造器

①在类的构造器中，可以显示的使用“this（形参列表）”方式，调用指定的本类中指定的其他构造器

②构造器不能通过“this（形参列表）”方式调用自己

③如果一个类中有n个构造器，则最多有n-1个构造器使用“this（形参列表）”

④“this（形参列表）”必须声明在当前构造器的首行

⑤构造器内部，最多只能声明一个“this（形参列表）”用来调用其他的构造器

6.一个例子

package yinhangyuyonghu;

public class Test {
    public static void main(String[] args) {
        Customer cust=new Customer("Jane","Smith");

        Account acct=new Account(1000,2000,0.0123);

        cust.setAccount(acct);

        cust.getAccount().deposit(100);
        cust.getAccount().withdraw(960);
        cust.getAccount().withdraw(2000);
    }
}

package yinhangyuyonghu;

public class Account {
    //属性
    private int id;//账户
    private double balance;//余额
    private double annualInterestRate;//年利率
    //结构体
    public Account(int id,double balance,double annualInterestRate){
        this.id=id;
        this.balance=balance;
        this.annualInterestRate=annualInterestRate;
    }
    //get/set方法
    public void setId(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    public double getBalance() {
        return balance;
    }
    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }
    public double getAnnualInterestRate() {
        return annualInterestRate;
    }
    //方法

    //取钱
    public void withdraw(double amount){
        if(balance<amount){
            System.out.println("余额不足");
            return;
        }
        balance-=amount;
        System.out.println("已取款"+amount);
    }
    //存钱
    public void deposit(double amount){
        if(amount>0){
            balance+=amount;
            System.out.println("已存款"+amount);
        }
    }
}

package yinhangyuyonghu;


public class Customer {
    //属性
    private String firstName;
    private String lastName;
    private Account account;
    //构造器
    public Customer(String firstName,String lastName){
        this.firstName=firstName;
        this.lastName=lastName;
    }

    //get/set方法
    public Account getAccount() {
        return account;
    }
    public void setAccount(Account account) {
        this.account = account;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }

    //方法
}

7.关键字：package、import的使用

①package关键字的使用

​ 1.为了更好的实现项目中类的管理、提供了包的概念

​ 2.使用package声明类或接口所属的包，声明在源文件首行

​ 3.每“.”一次代表一层文件目录

​ 补充：同一个包下不能够命名同名的接口、类

​ 不同的包下可以命名同名的接口、类

②import关键字的使用

​ 1.在源文件中显示的使用import结构导入指定包下的类、接口

​ 2.可以使用“xxx.*”的方式，表示可以导入xxx包下的所有结构

​ 3.如果使用的类或接口时Java.lang包定义下的，则可以省略import结构

​ 4.如果使用的类或接口时本包下定义的，则可以省略import结构

​ 5.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。

包名.类名（）；

​ 6.如果使用“xxx.*”方式表明可以调用xxx包下的所有结构，但如果使用的是xxx子包下的结构，则仍需要显示导入

​ 7.import stctic：导入值定类或接口中的静态结构：属性或方法

import static java.lang.System.*;

public class PackageImportTest {
    public static void main(String[] args) {
        out.println("HelloWorld");
    }

}

8.MAC设计模式