面向对象1

最新推荐文章于 2024-06-16 09:46:44 发布

#camellia#

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量63

点赞数

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_62619269/article/details/124879734

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

类和对象

类：对一类事物的描述，是抽象的、概念上的定义
对象：实际存在该事物中的该类事物的每个个体，因此也称为实例
属性=成员变量=field=域、字段
方法=成员方法=函数=method

//测试类
public class luanma {
    public static void main(String[] args) {
   //创建persion类对象=类的实例化
        Person p1=new Person();
        //调用对象的结构：属性、方法
        //调用属性：对象,属性
        p1.name="Tom";
        System.out.println(p1.name);
        //调用方法：对象.方法
        p1.eat();
        p1.Sleep();
    }
}
//创建类，设计类的成员
class Person{
    //属性
    String name;
    int age=1;
    //方法
    public void eat() {
        System.out.println("人可以吃饭");
    }
    public void Sleep() {
        System.out.println("人可以睡觉");
    }
}

对象的内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w0VDASmL-1653016271765)(https://cdn.jsdelivr.net/gh/kaolaaa/picture/202204201458782.png)]

属性与局部变量的对比

 * 属性（成员变量）  VS   局部变量
 * 1：相同点
 *    1.1：定义变量的格式：数据类型=变量名=变量值
 *    1.2：先声明，后使用
 *    1.3：变量都有对应的作用域
 * 2：不同点
 *    2.1：在类中声明的位置不同
 *    属性：直接定义在类的一对{}中
 *    局部变量：声明在方法内，方法形参，代码块内，构造器形参的变量
 *    2.2关于权限修饰符的不同
 *    属性：可以在声明属性的时候，指明其权限，使用权限修饰符
 *    常用的权限修饰符：private public 缺省 protected--->封装性
 *    局部变量：不能使用权限修饰符
 *    2.3默认初始化值不同
 *    属性：根据其类型，都有初始化值
 *    局部变量：没有默认初始化值，形参在调用时赋值即可
 *    2.4在内存中加载的位置不同
 *    属性：加载到堆空间
 *    局部变量：加载到栈空间
 * */

public class Test {
    public static void main(String[] args) {
        user u1=new user();
        System.out.println(u1.age);
        System.out.println(u1.name);
        u1.talk("日语");
        u1.eat();
    }
}
class user{
    //属性
    String name;
    int age;
    //局部变量
    public void talk(String language){//language :形参
        System.out.println("我们使用"+language+"进行交流");
    }
    public void eat(){
        String food="烙饼";
        System.out.println("北方人喜欢吃"+food);
    }
}

方法声明的格式

方法的重载：在一个类中，允许存在一个以上的同名方法，只要他们的参数个数和参数类型不同即可

/*
方法：描述类应该具有的功能   比如：Math类，Scanner类

方法的声明：权限修饰符 返回值类型 方法名（形参列表）{
            方法体
}
权限修饰符：private（私有）  public  protected  缺省
返回值类型：有返回值--》如果有则必须在方法申明时，指定返回值类型，还需要使用return 关键字来返回指定类型的变量或者常量
          无返回值--》方法声明的时候是有void，也不需要return
方法名：属于标识符，遵循规则“见名知意”
形参列表：可以声明0个、1个和多个形参
*/

public class Test {
    public static void main(String[] args) {
    }
}
//客户类
class Custom{
    //属性
    String name;
    int Age;
    boolean isMale;
    //方法
    public void eat(){
        System.out.println("客户吃饭！");
    }
    public void sleep(int hour){
        System.out.println("休息了"+hour+"个小时");
    }
    public String getName(){
        return name;
    }
}

return关键字的使用

return :
1作用范围：使用在方法体中
2作用：结束方法
      针对有返回值类型的方法，使用return 数据的方式返回所要的数据
3注意：return 关键字后面不可以声明执行语句
方法使用注意
1方法内可以调用当前类的属性和方法
2递归方法：方法a 中调用了方法A
3方法中不可以定义方法

匿名对象的使用

一：理解“万事万物皆对象”
1：在java 语言范畴中，将功能、结构等封装到类中，通过实例化，来调用具体的功能结构
》scanner String
》文件；file
》网络资源：url
2：设计到Java语言和前段、后端数据库交互时都体现为类、对象
二：匿名对象的使用
1:创建的对象，没有显示的赋给一个变量名，就是匿名对象
2：匿名对象只能调用一次

public class Test {
    public static void main(String[] args) {
    Custom p=new Custom();
    p=null;
    System.out.println(p);
    p.run();
    p.runTime(3);

    //匿名对象
        new Custom().runTime(3);
        new Custom().run();
    }
}
//客户类
class Custom{
    //属性
    String name;
    int Age;
    boolean isMale;
    //方法
    public void run(){
        System.out.println("一起跑步啊！");
    }
    public void runTime(int hour){
        System.out.println("跑了"+hour+"个小时");
    }
}

自定义数组工具类的封装

//自定义数组的工具类
public class Test {
        //求数组的最大值
        public int getMax (int [] arr){
            return 0;
        }
        //求数组的最小值
        public int getMin (int [] arr){
            return 0;
        }
        //求数组的总和
        public int getSum (int [] arr){
            return 0;
        }
        //求数组的平均值
        public int getAvg (int [] arr){
            return 0;
        }
        //反转数组
        public  void reverse (int [] arr){

        }
        //复制数组
        public int[] copy (int [] arr){
            return null;
        }
        //数组排序
        public void sort (int [] arr){

        }
        //遍历数组
        public void  print (int [] arr){

        }
        //查找指定元素
        public int getIndex (int [] arr,int dest){
            return 0;
        }
}

//调用
public class ArrayTest {
    public static void main(String[] args) {
        Test util=new Test();
        int []arr=new int[]{32,45,67,8,};
        int max=util.getMax(arr);
        System.out.println("最大值为"+max);
    }
}

可变个数的形参

jdk5.0新增的内容

public static void main(String[] args) {
                Test p=new Test();
                p.show(12);
                p.show("hello");
        }
public void show (int i){
                System.out.println(i);
       }
public void show (String i){
                System.out.println(i);
        }
        //可变个数的形参
public void show (String ...Strs){
        }
}

封装性

问题的引入:
当我们创建一一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受:属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(比如+ setlegs)
同时我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private )

–》这里的属性就体现了封装性：隐藏内部的复杂性，只对外公开简单的接口

public class Test {
        public static void main(String[] args) {
                Animal a=new Animal();
                a.age=12;
                a.eat();
                a.show();
                a.setlegs(6);//不让legs存在负号的情况
        }
}
class Animal{
        int age;
        private int  legs;//私有的，不能直接调用，隐藏起来
        public void  setlegs(int i){
                System.out.println("限制条件！！！！");
        }
        public void eat(){
                System.out.println("动物吃饭！");
        }
        public void show(){
                System.out.println("age="+age+",legs="+legs);
        }
}

封装性的体现
我们将类的属性私有化，（private）,这时候就形成了一个功能缺失，不能调用输出。所以提供一个公共的（public）方法来获取（getxxx）和设置（setxxx）

 public int  getlegs{
                return legs;
        }
public void  setlegs(int i){
              legs=i;
        }

//一个有返回值一个没有
//一个有形参一个没有

四种权限修饰的理解

java 规定：private 缺省 protected public

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3eLYeqlk-1653016271766)(https://cdn.jsdelivr.net/gh/kaolaaa/picture/202205091041285.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZrHVmSVy-1653016271766)(https://cdn.jsdelivr.net/gh/kaolaaa/picture/202205091058628.png)]

四种权限可以修饰类及类的内部结构：属性、方法、构造器、内部类
修饰类的话：只能使用缺省、public
总结封装性：java提供了四种权限修饰符来修饰类及其内部结构，体现类与类的结构在被调用的时候的可见性

构造器

construct：构造器的作用主要就是创建对象，初始化属性。如果没有定义类的构造器，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名(形参列表){}

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

总结属性赋值的先后顺序
1：默认初始化
2：显示初始化
3：构造器中赋值
4：通过对象.方法或者对象.属性赋值

public class Test {
        public static void main(String[] args) {
                //创建类的对象：new + 构造器
                Person p=new Person();
                p.eat();
                Person p1=new Person("Tom");
                System.out.println(p1.name);
        }
}
class Person {
        //属性
        String name;
        int age;
        //构造器：一个类中定义多个构造器也叫做重载
        public Person(){
                System.out.println("Person().....");
        }
        public Person(String n){
              name=n;
        }
        //方法
        public void eat() {
                System.out.println("吃饭！！！");
        }
}

JavaBean的使用

所谓JavaBean，java语言写成的可重用组件，是指符合如下标准的java类
1：类是公共的
2：有一个无参的公共构造器
3：有属性，且有对应的get/set方法

●用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

有点迷糊，老师说后续学javaweb的时候用一用就知道了

关键字this的使用

this可以用来修饰属性、方法和构造器
this修饰属性和方法：this被理解为当前对象（this.属性 this.方法通常情况下省略，当方法形参和属性同名时，必须使用this）

public class Test {
        public static void main(String[] args) {
                Person p=new Person();
                p.setname("tom");
                System.out.println(p.getname());
        }
}
class Person {
        private String name;
       public void setname (String n){
           name =n;
       }
       public String getname(){
           return  name;
       }
}
//这个时候如果想把n换成name(代码更容易被理解)，就可以使用this 关键字了
 public void setname (String name){
           this.name =name;
       }

package关键字的使用

1:为了更好的实现项目中类的管理，提供包的概念
2:使用package声明类或接口所属的包，声明在源文件的首行
3:包–》属于标识符，遵循规范（aaabbb），见名知意
4:每.一次，就代表一层文件目录
5:同一个包下，不能命名同名的接口和类,不同包下可以。

import关键字的使用

1：导入，在源文件中显示使用import结构导入指定包下的类和接口
2：声明在package和类中间
3：如果需要导入多个结构，并列写入即可
4：可以使用xxx.*的方法，表示导入Xxx包下面的所有结构
5：像String 和System 是核心包（java.long）下面的，所以如果使用这个包下面的就可以省略import

import com.sun.media.sound.EmergencySoundbank;
public class test {
    public static void main(String[] args) {
        EmergencySoundbank bank=new EmergencySoundbank();
    }
}

继承性的理解

继承性：子类继承父类的所有功能
一：优点
1：减少了代码的冗余，提高了代码的复用性
2：便于功能的扩展
3：为之后多态的使用，提供了前提
二：继承性的格式 class A extends B{}
A:子类，派生类
B：父类，基类
一旦子类A继承了父类B之后，就获取了B中声明的结构：属性和方法
特殊：父类中声明为private的属性和方法，子类继承后仍然可以获取，只是因为有封装性的影响，所以不能直接调用
子类继承父类以后，可以定义自己特有的属性和方法–实现功能的扩展
三：继承的规定
1：一个类可以被多个子类继承
2：一个类只能有一个父类–》单继承性
3：可以多层继承，是一个相对的概念，有直接父类和间接父类

package com;
public class person extends test {
   // String name;
    int height;
    public person(){

    }
    /*public void eat(){
        System.out.println("吃饭！！");
    }*/
    public void sport(){
        System.out.println("运动！！");
    }
    public void read(){
        System.out.println("读书！！");
    }
}

所有类都直接或者间接继承于.object类

方法的重写

在这里插入图片描述

/*
* 重写应用：重写以后，当创建子类对象以后，通过子类对象调用子类中的同名参数的方法时，实际执行的是子类重写父类的方法
* 规定：
*    方法的的申明：权限修饰符 返回值类型 方法名（形参列表）{//方法体}
*    约定俗称:子类中叫重写的方法，父类中叫被重写的方法
*            保证方法名和形参列表相同
*            子类重写的权限修饰符不小于父类  特殊：子类不能重写父类中权限为private的方法
*            返回值类型--》父类返回值类型是void 则子类相同
*                    --》父类返回值类型是A类   则子类可以是A类或者是A类的子类
*                    --》父类返回值类型是基本数据类型，则子类必须是相同的基本数据类型
*            throws 异常的类型（子类重写的异常类型不大于父类）
*/
public class Person {
    int age ;
    int height;
    public void eat(){
        System.out.println("吃饭");
    }
}
class Student extends Person {
    public void eat(){
        System.out.println("吃有营养的食物");
    }
}
class Test{
    public static void main(String[] args) {
        Student s=new Student();
        s.eat();
    }
}