13.面向对象一

Posted xingqisan

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了13.面向对象一相关的知识,希望对你有一定的参考价值。

一、面向对象学习内容

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);
} }

 

 

以上是关于13.面向对象一的主要内容,如果未能解决你的问题,请参考以下文章

VSCode自定义代码片段9——JS中的面向对象编程

译丨Yarn - Javascript 新一代套件管理

浅层了解String——Java面向对象基础(13)

雷军:“下一代 Ultra旗舰将面向全球发售”;戴尔宣布完全退出俄罗斯;TypeScript 4.8发布|极客头条

面向对象中的验证码类

Java 封装