JAVA面向对象

最新推荐文章于 2024-09-03 11:46:36 发布

鱿鱼圈是真鱿鱼吗

最新推荐文章于 2024-09-03 11:46:36 发布

阅读量590

点赞数 2

分类专栏：软件构造学习笔记文章标签： java 面向对象编程

本文链接：https://blog.csdn.net/sissi_1115/article/details/104664836

版权

软件构造学习笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 类的定义

1.1 成员变量

直接定义在类中，在方法外。

1.2 成员方法

不写static关键字。

public class Student {
//    成员变量
    String name;
    int grade;

//成员方法
    public void eat(){
        System.out.println("eat!");    
    }
}

2. 创建对象

导包
import 包名称.类名称；
对于和当前类属于同一个包的情况，可以省略包语句不写。
创建
类名称对象名 = new 类名称（）；
使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
注意：如果成员变量没有赋值，将会有一个默认值，规则和数组一样。

3. 面向对象三大特征

封装、继承、多态

3.1 封装

1. 方法就是一种封装
2. private也是一种封装

一旦使用了private进行修饰，那么本类当中仍然可以随意访问，但超出本类后不能直接访问。
间接访问private成员变量，就是定义一对Getter/Setter方法。除了boolean以外命名必须遵照setXxx和getXxx。
例如：

package day01.demo02;

public class Person {
    String name;
    private int age;

    public  void  show(){
        System.out.println(name+","+age);
    }

//    必须无返回值，有参数
    public void setAge(int num) {
        if (num < 100 && num >= 9) {
            age = num;
        } else {
            System.out.println("数据不合理");
        }
    }

//    必须有返回值，无参数
    public int getAge() {
        return age;
    }
}

同时，可以看到利用private还能有效处理数据筛选的问题，提高程序的安全性。如下程序中，当输入年龄值不在上述约定范围内中时，程序输出指定的报错语句。

package day01.demo02;

public class Demo02Persono {
    public static void main(String[] args) {
        Person one = new Person();
        one.show();

        one.name="YYQ";
        one.setAge(-20);
        one.show();
    }

}

在这里插入图片描述
对于boolean类型,Getter方法写成isXxx形式

private boolean male;
public boolean setMale(boolean b){
male=b
}
public boolean isMale(){
return male;
};

4. this关键字

当方法的局部变量和类的成员变量重名时，程序优先会使用局部变量。
当我们需要访问本类中的成员变量时：this.成员变量
(this一定出现在方法中）

通过谁调用的方法，谁就是this

5. 构造方法

构造方法：用来创建对象的方法。
构造方法的调用是通过new。
格式：public 类名称（参数类型参数名称）{
方法体
}

注意：

构造方法的名称必须与所在类的名称完全一致。
构造方法不写返回值类型（包括~~void~~ ）
构造方法不能return一个具体的返回值。
如果没有自行编写构造方法，则编译器会默认赠送一个无参构造方法。方法体不做任何事情
public Student( ){ };
但一旦编写了至少一个的构造方法，编译器将不再赠送。
构造方法也可以重载。

//构造方法（同时也是下文中无参数的构造方法）
package day01.demo04;

public class Student {
   public Student(){
       System.out.println("~~~HELLO~~~");
   }
}

//调用
package day01.demo04;

public class Demo04Student {
   public static void main(String[] args) {
       Student student=new Student();
   }
}

6. 标准的类结构

一个标准的类（Java Bean）包括：

所有成员变量都用private修饰
每个成员变量的Getter/Setter方法
一个无参数的构造方法
一个全参数的构造方法
在idea中可以直接使用软件自带的快捷功能自动生成（编写完成员变量后）
Satter&Getter： code->genarate->Satter&Getter->shift全选
无参数的构造方法：genarate->constructor->select none
全参数的构造方法：genarate->constructor->shift全选

调用时
在这里插入图片描述

7. 匿名对象

匿名对象格式：new 类名称（）；（或new 类名称.xxx = ···）
注意：匿名对象只能使用一次。故当有一个变量只使用一次时可以采用匿名对象。
使用匿名对象传参

package day01.demo02;

import java.util.Scanner;

public class Demo02Anonymous {
    public static void main(String[] args) {
//        使用匿名对象传参
        methodParam(new Scanner(System.in));
    }

    public static void methodParam(Scanner sc) {
        int num = sc.nextInt();
        System.out.println("输入的是"+ num);

    }
}

使用匿名对象作为方法的返回值

package day01.demo02;

        import java.util.Scanner;

public class Demo02Anonymous {
    public static void main(String[] args) {
//        使用匿名对象作为返回值类型
        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("输入的是" + num);
    }
    public static Scanner methodReturn(){
        //new了一个匿名对象
        return new Scanner(System.in);        
    }
}

8. 对象数组

如要创建一个数组，其中存储3个Person对象时。

Person[] array = new Person[3];

Person one = new Person(···)；
···

9. ArrayList类

ArrayList集合的长度可以改变
在API中不难搜索到ArrayList，而其后的代表泛型。也就是集合中的所有元素类型统一为括号中的类型。
注意：
泛型只能是引用类型，不能是基本类型（byte short int long,float double char boolean）.
对ArrayList集合，直接打印得到的不是地址值而是内容。当内容为空时，得到中括号[]。

public class Demo02ArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();  //  （JDK1.7+版本等号右侧括号中可以不写内容） 
    }
}

向集合添加数据时，使用add方法。

public class Demo02ArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();

        list.add("HELLO");
        list.add("EVERYONE!");
        //        list.add(100);  指定必须存入的是字符串类型
        System.out.println(list);

    }
}

10. ArrayList常用方法

在这里插入图片描述
具体使用见：当需要遍历集合时，可以缩写list.fori再加上打印语句在idea中即可出现如下循环。

for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

当存储基本类型数据时，需要使用基本类型对应的“包装类”。

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

具体使用如下：

ArraryList<Integer> List = new ArrayList<>();
list.add(100);
list.add(200);

int num = list.get(1);
System.out.println(num);

例题1：生成5个1~100之间的随机数，添加到集合并遍历集合。

package day01.demo02;

import java.util.ArrayList;
import java.util.Random;

public class Demo02ArrayListRandom {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
//       每个数字都添加到集合
        for (int i = 0; i < 5; i++) {
            int num = r.nextInt(100) + 1;
            list.add(num);
        }
//       遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

集合也可以作为方法的参数
例如：当我们需要改变集合的输出方式，打比方使用{}代替[]，分隔符用~代替，时：

package day01.demo02;

import java.util.ArrayList;

public class Demo02ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("马云");
        list.add("马化腾");

        System.out.println(list); //[,,]
        printArrayList(list);
    }

    public static void printArrayList(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i);
            if(i==list.size()-1)
                System.out.println(name+"}");
            else {
                System.out.print(name + "~");  //注意这里不能用prinln了
            }
        }
    }
}

11. 静态static

使用静态static关键字后，其内容不再属于对象，而是属于类。因此凡是本类的对象，都共享这个内容。

11.1 成员变量

当成员变量使用static后，这个变量属于所在的类，多个对象共享一份数据。
例如：下列代码中利用room和idCounter分别展示了共享数据的用处。

package day01.demo04;

public class Student {
       private int id; //学号
       private String name;
       private int age;
       static String room;  //所在教室
//    学号计数器，每new一个新对象后计数器++
       private static int idCounter = 0;

   public Student() {
       this.id = idCounter++;
   }

   public Student(String name, int age) {
       this.name = name;
       this.age = age;
       this.id = ++idCounter;
   }

   public int getId() {
       return id;
   }

   public void setId(int id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }
}

package day01.demo04;

public class Demo04Static {
    public static void main(String[] args) {
        Student one = new Student("YYQ",19);
        one.room = "1803009";
        System.out.println("one的学号是："+one.getId());


        Student two = new Student("QYY",15);
        System.out.println("two的教室是："+two.room);
        System.out.println("two的学号是："+two.getId());
    }
}

11.2 成员方法

static修饰成员方法后变成静态方法。静态方法不属于对象，属于类。
没有static时，必须先创建对象，然后通过对象使用，例如。
先定义一个类MyClass

MyClass obj = new Myclass();  //先创建对象
obj.method();

对于静态方法，可以通过对象名或类名【推荐】进行调用。

obj.methodStatic();   //通过对象名
Myclass.methodStatic();   //通过类名称

对于一个class下的静态方法，可以省略类名称。例如：
在这里插入图片描述

注意：

静态不能直接访问非静态
静态方法中不能用this（this代表当前对象，也就是通过谁调用的方法，但静态方法与对象无关）

11.3 静态内存

在这里插入图片描述

11.4 静态代码块

在这里插入图片描述注意：第一次使用本类时，静态代码才执行且仅执行一次。
写一个类如下：

package day01.demo05;

public class Person {
    static{
        System.out.println("静态代码执行");
    }
    public Person(){
        System.out.println("构造方法执行");
    }
}

再通过如下进行测试
在这里插入图片描述

12. 继承

12.1 继承的格式

父类的格式：一个普通的类定义
子类的格式：

public class 子类名称 extends 父类名称{
}

12.2 继承中访问成员变量

当父子类的继承关系中成员变量重名时：

直接通过子类对象访问成员变量：
等号左边是谁就先用谁，左边没有这个成员变量时再向上找。
间接通过成员方法访问成员变量：
方法属于谁（在父类还是子类中定义的）就先用谁，没有这个方法时再向上找。

12.3 子类、父类、局部变量重名

局部变量：直接写成员变量名
本类的成员变量：this.成员变量名
父类的成员变量：super.成员变量名
例如一个子类中：
在这里插入图片描述

12.3 子类父类成员方法重名

即当父类子类中出现同名的成员方法时：
创建的对象是谁就优先用谁，没有时再找父类。

如：父类子类中都有method方法时
在这里插入图片描述注意：无论是成员方法还是成员变量，这个子类中没有时都首先找它的父类而非它的子类。

12.4 继承中方法的覆盖重写

对比重载：
重写：方法的名称一样，参数列表也一样
重载：方法的名称一样，参数列表不一样

注意事项;

@Override:写在方法前面。可以检测是否是正确的覆盖重写。（不写也可以，但尽量写）

@Override
public String method() {
}

子类方法的返回值必须小于等于父类的返回值范围
p.s java.lang.Object类是所有类的公共最高父类
子类方法的权限必须大于等于父类的权限修饰符
public > protected > 什么都不写 > private

应用：当需要对老版手机工呢做一个修改更新时，对着重需要改进的类进行继承重写：
（此处前提是父类有一个show方法）
在这里插入图片描述

12.4 继承中构造方法的访问

子类构造方法中有一个默认隐含的super（）调用，所以一定是先调用的父类构造，后执行的子类构造。
子类构造可以通过super关键字调用父类重载构造。
super的父类构造调用必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造。

注意：super（）调用的一定是父类的无参构造方法，如果要调用父类重载构造方法（也就是和无参的方法名相同但需要传参）时可以super（…）

12.5 super关键字的用法

在这里插入图片描述

12.6 this关键字的使用

本类成员方法中，访问本类的成员变量
本类成员方法中，访问本类另一个成员方法
如图，强调调用的是本类当中的而非父类中的
本类构造方法中，访问本类另一个构造方法。注意：
1. this（…）调用也必须是构造方法中的第一个语句，也是唯一一个
2. super和this两种构造调用不能同时使用