13.面向对象一

Posted 2020-11-26 xingqisan

一、面向对象学习内容

package com.atguigu.java;
/*
 * 一、Java面向对象学习的三条主线：（第4-6章）
 * 1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 * 
 * 2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)
 * 
 * 3.其它关键字：this、super、static、final、abstract、interface、package、import等
 * 
 * “大处着眼，小处着手”
 * 
 * 
 * 二、“人把大象装进冰箱”
 * 
 * 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
 * 
 * ① 把冰箱门打开
 * ② 抬起大象，塞进冰箱
 * ② 把冰箱门关闭
 * 
 * 2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
 * 
 * 人{
 *         打开(冰箱){
 *             冰箱.开开();
 *         }
 * 
 *         抬起(大象){
 *             大象.进入(冰箱);
 *         }
 * 
 *         关闭(冰箱){
 *             冰箱.闭合();
 *         }
 * 
 * }
 * 
 * 
 * 冰箱{
 *         开开(){}
 *         闭合(){}
 * }
 * 
 * 大象{
 *         进入(冰箱){
 *         }
 * }
 * 
 * 三、面向对象的两个要素：
 * 类：对一类事物的描述，是抽象的、概念上的定义
 * 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
 * >面向对象程序设计的重点是类的设计
 * >设计类，就是设计类的成员。
 * 
 */
public class OOPTest {

}

二、类的设计

package com.atguigu.java;
/*
 * 一、设计类，其实就是设计类的成员
 * 
 *  属性 = 成员变量 = field = 域、字段
 *  方法 = 成员方法 = 函数 = method
 * 
 *  创建类的对象 = 类的实例化 = 实例化类
 * 
 * 二、类和对象的使用（面向对象思想落地的实现）：
 *  1.创建类，设计类的成员
 *  2.创建类的对象
 *  3.通过“对象.属性”或“对象.方法”调用对象的结构
 *  
 * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
 *   意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
 *   
 * 四、对象的内存解析
 */
//测试类
public class PersonTest {
    public static void main(String[] args) {
        //2. 创建Person类的对象
        Person p1 = new Person();
        //Scanner scanner = new Scanner(System.in);
        
        //调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        p1.name = "Tom";
        p1.isMale = true;
        System.out.println(p1.name);
        
        //调用方法：“对象.方法”
        p1.eat();
        p1.sleep();
        p1.talk("Chinese");
        
        //*******************************
        Person p2 = new Person();
        System.out.println(p2.name);//null
        System.out.println(p2.isMale);
        //*******************************
        //将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
        Person p3 = p1;
        System.out.println(p3.name);//Tom
        
        p3.age = 10;
        System.out.println(p1.age);//10
        
    }
}

//1.创建类，设计类的成员
class Person{
    
    //属性
    String name;
    int age = 1;
    boolean isMale;
    
    //方法
    public void eat(){
        System.out.println("人可以吃饭");
    }
    
    public void sleep(){
        System.out.println("人可以睡觉");
    }
    
    public void talk(String language){
        System.out.println("人可以说话,使用的是：" + language);
    }
    
}

三、类中属性的使用

package com.atguigu.java;
/*
 * 类中属性的使用
 * 
 * 属性（成员变量）   vs  局部变量
 * 1.相同点：
 *         1.1  定义变量的格式：数据类型  变量名 = 变量值
 *         1.2 先声明，后使用
 *         1.3 变量都有其对应的作用域 
 * 
 * 
 * 2.不同点：
 *         2.1 在类中声明的位置的不同
 *         属性：直接定义在类的一对{}内
 *         局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 *         
 *         2.2 关于权限修饰符的不同
 *         属性：可以在声明属性时，指明其权限，使用权限修饰符。
 *             常用的权限修饰符：private、public、缺省、protected  --->封装性
 *             目前，大家声明属性时，都使用缺省就可以了。
 *         局部变量：不可以使用权限修饰符。
 * 
 *         2.3 默认初始化值的情况：
 *         属性：类的属性，根据其类型，都有默认初始化值。
 *             整型（byte、short、int、long）：0
 *             浮点型（float、double）：0.0
 *             字符型（char）：0  （或‘u0000‘）
 *             布尔型（boolean）：false
 * 
 *             引用数据类型（类、数组、接口）：null
 * 
 *         局部变量：没有默认初始化值。
 *          意味着，我们在调用局部变量之前，一定要显式赋值。
 *             特别地：形参在调用时，我们赋值即可。
 * 
 *         2.4 在内存中加载的位置：
 *         属性：加载到堆空间中   （非static）
 *         局部变量：加载到栈空间
 * 
 */
public class UserTest {
    
    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);
        
        u1.talk("韩语");
        
        u1.eat();
        
    }
}

class User{
    //属性（或成员变量）
    String name;
    public int age;
    boolean isMale;
    
    
    public void talk(String language){//language:形参，也是局部变量
        System.out.println("我们使用" + language + "进行交流");
        
    }
    
    public void eat(){
        String food = "烙饼";//局部变量
        System.out.println("北方人喜欢吃：" + food);
    }
    
}

四、类中方法的声明和使用

package com.atguigu.java;
/*
 * 类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：Math类：sqrt()
andom() ...
 *     Scanner类：nextXxx() ...
 *     Arrays类：sort()  binarySearch()  toString()  equals()  ...
 * 
 * 1.举例：
 * public void eat(){}
 * public void sleep(int hour){}
 * public String getName(){}
 * public String getNation(String nation){}
 * 
 * 2. 方法的声明：权限修饰符  返回值类型  方法名(形参列表){
 *                     方法体
 *               }
 *   注意：static、final、abstract 来修饰的方法，后面再讲。
 *   
 * 3. 说明：
 *         3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
 *             Java规定的4种权限修饰符：private、public、缺省、protected  -->封装性再细说
 * 
 *         3.2 返回值类型： 有返回值  vs 没有返回值
 *             3.2.1  如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
 *                return关键字来返回指定类型的变量或常量：“return 数据”。
 *                   如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
 *               使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 * 
 *             3.2.2 我们定义方法该不该有返回值？
 *                 ① 题目要求
 *                 ② 凭经验：具体问题具体分析
 * 
 *      3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *      
 *      3.4 形参列表： 方法可以声明0个，1个，或多个形参。
 *         3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
 *         
 *         3.4.2 我们定义方法时，该不该定义形参？
 *                 ① 题目要求
 *                 ② 凭经验：具体问题具体分析
 *      
 *      3.5 方法体：方法功能的体现。         
 * 
 *  4.return关键字的使用：
 *      1.使用范围：使用在方法体中
 *      2.作用：① 结束方法
 *            ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
 *      3.注意点：return关键字后面不可以声明执行语句。
 *      
 *  5. 方法的使用中，可以调用当前类的属性或方法
 *          特殊的：方法A中又调用了方法A:递归方法。
 *     方法中，不可以定义方法。
 */
public class CustomerTest {
    public static void main(String[] args) {
        
        Customer cust1 = new Customer();
        
        cust1.eat();
        
        //测试形参是否需要设置的问题
//        int[] arr = new int[]{3,4,5,2,5};
//        cust1.sort();
        
        cust1.sleep(8);
        
    }
}

//客户类
class Customer{
    
    //属性
    String name;
    int age;
    boolean isMale;
    
    //方法
    public void eat(){
        System.out.println("客户吃饭");
        return;
        //return后不可以声明表达式
//        System.out.println("hello");
    }
    
    public void sleep(int hour){
        System.out.println("休息了" + hour + "个小时");
        
        eat();
//        sleep(10);
    }
    
    public String getName(){
        
        if(age > 18){
            return name;
            
        }else{
            return "Tom";
        }
    }
    
    public String getNation(String nation){
        String info = "我的国籍是：" + nation;
        return info;
    }
    
    //体会形参是否需要设置的问题
//    public void sort(int[] arr){
//        
//    }
//    public void sort(){
//        int[] arr = new int[]{3,4,5,2,5,63,2,5};
//        //。。。。
//    }
    
    public void info(){
        //错误的
//        public void swim(){
//            
//        }
        
    }
}

五、再谈方法
　　（一）方法的重载（overload）

package com.atguigu.java1;
/*
 * 方法的重载（overload）  loading...
 * 
 * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
 *     
 *  "两同一不同":同一个类、相同方法名
 *            参数列表不同：参数个数不同，参数类型不同
 * 
 * 2. 举例：
 *    Arrays类中重载的sort() / binarySearch()
 * 
 * 3.判断是否是重载：
 *    跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
 *    
 * 4. 在通过对象调用方法时，如何确定某一个指定的方法：
 *      方法名 ---> 参数列表
 */
public class OverLoadTest {
    public static void main(String[] args) {
        
        OverLoadTest test = new OverLoadTest();
        test.getSum(1,2);
        
        
    }
    
    //如下的4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    
    public void getSum(String s ,int i){
        System.out.println("3");
    }
    
    public void getSum(int i,String s){
        System.out.println("4");
    }
    
    //如下的3个方法不能与上述4个方法构成重载
//    public int getSum(int i,int j){
//        return 0;
//    }
    
//    public void getSum(int m,int n){
//        
//    }
    
//    private void getSum(int i,int j){
//        
//    }
    
    
}

　　（二）可变个数形参的方法

package com.atguigu.java1;
/*
 * 可变个数形参的方法
 * 
 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 *   2.1 可变个数形参的格式：数据类型 ... 变量名
 *   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
 *   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *   2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
 *   2.5 可变个数形参在方法的形参中，必须声明在末尾
 *      2.6  可变个数形参在方法的形参中,最多只能声明一个可变形参。
 * 
 */
public class MethodArgsTest {
    
    public static void main(String[] args) {
        
        MethodArgsTest test = new MethodArgsTest();
        test.show(12);
//        test.show("hello");
//        test.show("hello","world");
//        test.show();
        
        test.show(new String[]{"AA","BB","CC"});
        
    }
    
    
    public void show(int i){
        
    }
    
    public void show(String s){
        System.out.println("show(String)");
    }
    
    public void show(String ... strs){
        System.out.println("show(String ... strs)");
        
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
    //不能与上一个方法同时存在
//    public void show(String[] strs){
//        
//    }
    
    //The variable argument type String of the method 
    //show must be the last parameter
//    public void show(String ...strs,int i){
//        
//    }
    
}

　　（三）方法参数的值传递机制

package com.atguigu.java1;
/*
 * 
 * 关于变量的赋值：
 * 
 *  如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 *  如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 * 
 */
public class ValueTransferTest {
    
    public static void main(String[] args) {
        
        System.out.println("***********基本数据类型：****************");
        int m = 10;
        int n = m;
        
        System.out.println("m = " + m + ", n = " + n);
        
        n = 20;
        
        System.out.println("m = " + m + ", n = " + n);
        
        System.out.println("***********引用数据类型：****************");
        
        Order o1 = new Order();
        o1.orderId = 1001;
        
        Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
        
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
        
        o2.orderId = 1002;
        
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
        
    }
    
}

class Order{
    
    int orderId;
    
}

package com.atguigu.java1;
/*
 * 方法的形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明的小括号内的参数
 *   实参：方法调用时，实际传递给形参的数据
 * 
 * 2.值传递机制：
 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
 * 
 */
public class ValueTransferTest1 {
    public static void main(String[] args) {
        
        int m = 10;
        int n = 20;
        
        System.out.println("m = " + m + ", n = " + n);
        //交换两个变量的值的操作
//        int temp = m ;
//        m = n;
//        n = temp;
        
        ValueTransferTest1 test = new ValueTransferTest1();
        test.swap(m, n);
        
        System.out.println("m = " + m + ", n = " + n);
        
        
    }
    
    
    public void swap(int m,int n){
        int temp = m ;
        m = n;
        n = temp;
    }
}

package com.atguigu.java1;

public class ValueTransferTest2 {
    
    public static void main(String[] args) {
        
        Data data = new Data();
        
        data.m = 10;
        data.n = 20;
        
        System.out.println("m = " + data.m + ", n = " + data.n);
        
        //交换m和n的值
//        int temp = data.m;
//        data.m = data.n;
//        data.n = temp;
        
        ValueTransferTest2 test = new ValueTransferTest2();
        test.swap(data);
        
        
        System.out.println("m = " + data.m + ", n = " + data.n);
        
    }
    
    public void swap(Data data){
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
    
}

class Data{
    
    int m;
    int n;
    
}

　　（四）递归方法

　　　　递归方法：一个方法体内调用它自身。

　　　　方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

　　　　递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

//计算1-100之间所有自然数的和
public int sum(int num){
if(num == 1){
return 1;
}else{
return num + sum(num - 1);
} }