自学Java---基础语法---第六天

最新推荐文章于 2023-11-29 17:23:22 发布

我本凡人一念云泥

最新推荐文章于 2023-11-29 17:23:22 发布

阅读量501

点赞数

分类专栏： java基础学习

本文链接：https://blog.csdn.net/qq_43532655/article/details/107326333

版权

java基础学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

引用数据类型

引用数据类型分析

我们可以把类的类型为两种：
第一种，Java为我们提供好的类，如Scanner类，Random类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

自定义数据类型概述

我们在Java中，将现实生活中的事物抽象成了代码。这时，我们可以使用自定义的数据类型（类）来描述（映射）现实生活中的事物。
类，它是引用数据类型，与之前学习的所有引用数据类型相同，自定义类也是一种数据类型。只是自定义类型并非Java为我们预先提供好的类型，而是我们自己定义的一种引用数据类型用来描述一个事物。

类的定义与使用

java代码映射成现实事物的过程就是定义类的过程。
我们就拿一部手机进行分析，它能用来做什么呢？它可以打电话，上网，聊微信等，这些就是手机所提供的功能，也就是方法；手机也有它的特征，如颜色、尺寸大小、品牌型号等，这些就是手机的特征，也就是属性。

类的定义格式

创建java文件，与类名相同
public class 类名{
数据类型属性名称1；
数据类型属性名称2；
…
}
示例

public class Phone{
	//类的名称我们给起名为Phone，类中包含了三个属性（brand品牌型号、color颜色、size尺寸大小）。
	//注意，类中定义的属性没有个数要求。
	//属性
	String brand;//品牌
	String color;//颜色
	double size;//尺寸
}

类的使用格式

导包：我们将所有的类放到同一个文件夹下，可以避免导包。
创建对象：数据类型  变量名 = new 数据类型();
调用方法：目前我们定义的自定义类不涉及方法，只是属性（自定义类中的方法部分在面向对象部分讲解）
访问属性：变量名.属性 (这是当前的方式，后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)

示例

public class Test {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.brand="华为";
        p.color="至尊黑";
        p.size=5.5;
        System.out.println("手机品牌为: " + p.brand);
        System.out.println("手机颜色为: " + p.color);
        System.out.println("手机尺寸大小为: " + p.size);
    }
}

自定义数据类型注意事项与内存图

上述代码中，通过类Phone创建出来的变量p，它相当于我们生活中的盒子，里面包含了它能够使用的属性。
通过 p.属性名就可以对属性进行操作
与引用类型数组类似，引用类型的自定义类型的变量，直接变量时，结果为对象地址值，这里可以通过内存图简单解释。
在这里插入图片描述

ArrayList集合

在前面我们学习了数组，数组可以保存多个元素，但在某些情况下无法确定到底要保存多少个元素，此时数组将不再适用，因为数组的长度不可变。例如，要保存一个学校的学生，由于不停有新生来报道，同时也有学生毕业离开学校，这时学生的数目很难确定。为了保存这些数目不确定的元素，JDK中提供了一系列特殊的类，这些类可以存储任意类型的元素，并且长度可变，统称为集合。在这里，我们先介绍ArrayList集合，其他集合在后续课程中学习。
ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。

集合的创建

创建集合的常用格式在此说明一下：
导包：import java.util.ArrayList;
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
集合中存储的元素，只能为<>括号中指定的数据类型元素；
“<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；
下面给出8种基本数据类型所对应的引用数据类型表示形式:

基本数据类型	对应的引用数据类型表示形式
byte	Byte
short	Short
int	Integer
long	Long
double	Double
char	Character
boolean	Boolean

示例
存储String类型的数据
ArrayList list = new ArrayList();
存储int类型的数据
ArrayList list = new ArrayList();
存储Phone类型的数据
ArrayList list = new ArrayList();

集合中常用的方法

方法声明	功能描述
boolean add(Object obj)	将指定元素obj追加到集合的末尾
Object[] toArray()	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
Object get（int index）	返回集合中指定位置上的元素
int size（）	返回集合中的元素个数
boolean contains(Object o)	如果此列表中包含指定的元素，则返回 true。
boolean isEmpty()	如果此列表中没有元素，则返回 true
remove(int index)	移除此列表中指定位置上的元素。
set(int index, E element)	用指定的元素替代此列表中指定位置上的元素。
void clear()	移除此列表中的所有元素。

强调一点，ArrayList集合相当于是一个长度可变的数组，所以访问集合中的元素也是采用索引方式访问，第一个元素存储在索引0的位置，第二个元素存储在索引1的位置，依次类推。

示例

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 1; i < 5; i++) {
            list.add(i);//向集合中添加元素
        }
        System.out.println(Arrays.toString(list.toArray()));//运行结果[1, 2, 3, 4]
        System.out.println(list.get(2));//运行结果3
        System.out.println(list.size());//运行结果4
        System.out.println(list.contains(3));//运行结果true
        System.out.println(list.isEmpty());//运行结果false
        list.remove(2);
        System.out.println(Arrays.toString(list.toArray()));//运行结果[1, 2, 4]
        list.set(0, 10);
        System.out.println(Arrays.toString(list.toArray()));//运行结果[10, 2, 4]
        list.clear();
        System.out.println(list.size());//运行结果0
    }
}

集合的遍历

通过集合遍历，得到集合中每个元素，这是集合中最常见的操作。集合的遍历与数组的遍历很像，都是通过索引的方式

 2public class ArrayListDemo02 {
 3	public static void main(String[] args) {
 4		//创建ArrayList集合
 5		ArrayList<Integer> list = new ArrayList<Integer>();
 6		//添加元素到集合
 7		list.add(13);
 8		list.add(15);
 9		list.add(22);
 10		list.add(29);
 11		//遍历集合
 12		for (int i = 0; i < list.size(); i++) {
 13			//通过索引，获取到集合中每个元素
 14			int n = list.get(i);
 15			System.out.println(n);
 16		}
 17	}
 18}

上述代码中，第5行定义了一个可以存储int元素的集合；第7-10行，实现将int类型数值存储到集合中；第12-16行，实现遍历集合元素。这里要强调一点，get方法返回值的类型为集合中元素的类型。

集合中的常用方法补充

boolean add（int index, Object obj）
功能：在集合中指定index位置，添加新元素obj
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用add(1，“javaWeb”)后，集合list中的元素为[“java”,“javaWeb”,“JavaEE”]。
Object set（int index, Object obj）
功能：用指定元素obj替代集合中指定index位置的元素
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用set(0，“javaWeb”)后，集合list中的元素为[“javaWeb”,“JavaEE”]。
Object remve（int index）
功能：从集合中删除指定index处的元素，返回该元素
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用remove(0)后，集合list中的元素为[“JavaEE”]，返回值为“java”。
void clear（）
功能：清空集合中所有元素
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用clear()后，集合list中的元素为空[]。

ArrayList的基本用法和特点
特点：
有序的：按照添加的顺序
不唯一：同一个元素可以装多次
1:如何创建泛型对象
ArrayList<泛型> list=new ArrayList<>();

2:如何添加元素：
一次添加一个元素：
list.add(元素);
一次添加多个元素：
Collections.addAll(集合，元素，元素，…);
3:得到集合元素的个数
list.size();
4:得到某一个元素
list.get(下标);
5：如何判断集合里面是否出现指定元素
list.contains();
6:遍历
for+下标
for(int x=0;x<list.size();x++){
//x->下标
//list.get(元素)；
}
foreache
for(集合的泛型 x :list){
//x->元素
}

随机点名器

定义学生类

public class Student {
    String name;
    int age;
}

封装功能方法

public class Function {
    public static void addStudent(ArrayList<Student> list) {
        Scanner sc = new Scanner(System.in);
        for (int i = 1; i < 4; i++) {
            Student s = new Student();
            System.out.println("存储第"+i+"个学生姓名：");
            s.name = sc.next();
            System.out.println("存储第"+i+"个学生年龄：");
            s.age = sc.nextInt();
            list.add(s);
        }
    }

    public static void printStudent(ArrayList<Student> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println("姓名："+list.get(i).name+",年龄："+list.get(i).age);
        }
    }
    public static void randomStudent (ArrayList<Student> list){
        int i = new Random().nextInt(list.size());
        System.out.println("被随机点名的同学："+list.get(i).name+",年龄："+list.get(i).age);
    }
}

调用方法

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student>();
        Function.addStudent(list);
        Function.printStudent(list);
        Function.randomStudent(list);
    }
}

库存管理案例

定义商品类

public class Commodity {
    String brand;
    double price;
    int stock;
}

封装功能方法

public class Function {
    public static void printHead(ArrayList<Commodity> list){
        System.out.println("----------------库存管理----------------");
        System.out.println("1.查看库存清单");
        System.out.println("2.修改商品库存数量");
        System.out.println("3.退出");
        System.out.println("请输入要执行的操作序号");
        int num = new Scanner(System.in).nextInt();
       over:while (true){
            switch (num){
                case 1:
                    checkInventory(list);
                    break over;
                case 2:
                    modifyInventory(list);
                    break over;
                case 3:
                    break over;
                default:
                    System.err.println("编号输入有误，请重新输入");
                    printHead(list);
            }
        }
    }

    public static void modifyInventory(ArrayList<Commodity> list) {
        System.out.println("------------修改商品库存数量-----------");
        for (int i = 0; i < list.size(); i++) {
            Commodity item = list.get(i);
            System.out.println("请输入"+ item.brand +"商品库存数量");
            item.stock = new Scanner(System.in).nextInt();
            list.set(i,item);
        }
        System.out.println("修改后的结果是 ：");
        checkInventory(list);
    }

    public static void checkInventory(ArrayList<Commodity> list) {
        int count=0;
        double sum = 0;
        System.out.println(" 型 号" + "\t"+"价 格"+"\t"+"库存");
        for (int i = 0; i < list.size(); i++) {
            count+=list.get(i).stock;
            sum+=list.get(i).stock*list.get(i).price;
            System.out.println(list.get(i).brand+ "\t"
            			+list.get(i).price+ "\t"+list.get(i).stock);
        }
        System.out.println("库存总计 ： " + count);
        System.out.println("库存金额总计 ：" + sum);
    }
}

调用方法

public class Test {
    public static void main(String[] args) {
        ArrayList<Commodity> list = new ArrayList<Commodity>();
        for (int i = 0; i < 2; i++) {
            Commodity c = new Commodity();
            c.brand ="华为"+(i+1)+"代";
            c.price =(i+1)*1200;
            c.stock=(i+1)*10;
            list.add(c);
        }
        Function.printHead(list);
    }


}

总结

引用数据类型（类）
类的类型为两种：
第一种，Java为我们提供好的类，如Scanner类，Scanner类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。
第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。
创建类的格式
public class 类名 {
//可以定义属性
//也可以定义方法
}
使用类的格式：
类名变量名 = new 类名();
使用类中的属性与方法格式
使用属性：变量名.属性
使用方法：变量名.方法()
ArrayList集合
它属于引用数据类型（类）。我们可以看作一个长度可变的数组。
创建集合的方式
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
集合中的常用方法
boolean add（Object obj）
Object get（int index）
int size（）
boolean add（int index, Object obj）
Object set（int index, Object obj）
Object remve（int index）
void clear（）

作业

1.简述自定义数据类型的定义格式和使用方式？
class MyObject{}
class Demo{
public static void main(){
MyObject m = new MyObject();//定义了数据类型
}
}
2.简述ArrayList集合的定义格式和常用方法的功能？

格式:ArrayList<Object> array = new ArrayList<Object>();

add(Obbject);//直接储存元素
add(index,Object);在指定位置储存元素
size();//获取集合长度
iterator();//获取集合的迭代方式
set(index,Object);//设置指定元素
get(index);//获取指定元素
remove(index);//删除指定位置的元素
4.以下选项错误的是？
A.获取数组的长度用length方法//错误是属性
B.获取字符串的长度用length属性//错误是方法
C.获取集合ArrayList的长度用length方法//错误用size();方法
D.获取数组的长度用length属性//正确
E.获取字符串的长度用length方法//正确
F.获取集合ArrayList的长度用length属性//错误
G.获取集合ArrayList的长度用size属性//错误
H.获取集合ArrayList的长度用size方法//正确
5.定义一个学生类Student，包含三个属性姓名、年龄、性别，创建三个学生对象存入ArrayList集合中。
A：遍历集合遍历输出。
B：求出年龄最大的学生，让后将该对象的姓名变为：葫芦娃。

public class Student {
  String name;
  String sex;
  int age;
    public Student(){

  }
  public Student(String name,String sex,int age){

  }
}

public class Function {
    public static void function(ArrayList<Student> list){
       public static void function(ArrayList<Student> list){
        Student s1 = new Student("张三","男",20);
        list.add(s1);
        Student s2 = new Student("李四","男",18);
        list.add(s2);
        Student s3 = new Student("王五","女",25);
        list.add(s3);
    }
    }
    public static void modifyFunction(ArrayList<Student> list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).name+"\t"+list.get(i).sex+"\t"+list.get(i).age);
        }
        int max =0;
        int index = 0;
        for (int i = 0; i < list.size(); i++) {
            if (max<list.get(i).age){
                max=list.get(i).age;
                index=i;
            }
        }
        Student s = list.get(index);
        s.name="葫芦娃";
        list.set(index,s);
        System.out.println("修改后的结果是 ：");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).name+"\t"+list.get(i).sex+"\t"+list.get(i).age);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student>();
        Function.function(list);
        Function.modifyFunction(list);
    }
}

6.定义一个手机类Phone，包含三个属性品牌(brand)、价格(price)、颜色(color)。
创建四个手机(“小米”、“华为”、“乐视”、“奇酷”)对象存入ArrayList集合中，并遍历输出。

public class Phone {
  String brand;
  double price;
  String color;
}

public class Test {
    public static void main(String[] args) {
        Phone huawei = new Phone();
        huawei.brand="note5";
        huawei.price=4888;
        huawei.color="至尊黑";
        Phone leshi = new Phone();
        leshi.brand="le6";
        leshi.price=3888;
        leshi.color="暖光白";
        Phone xiaomi = new Phone();
        xiaomi.brand = "xiaomi5";
        xiaomi.price=2888;
        xiaomi.color="炫光蓝";
        Phone qiku = new Phone();
        qiku.brand="qiku3";
        qiku.price=1888;
        qiku.color="可爱粉";
        //存储
        ArrayList<Phone> list= new ArrayList<Phone>();
        list.add(huawei);
        list.add(leshi);
        list.add(xiaomi);
        list.add(qiku);

        //遍历
        System.out.println("品牌"+"\t"+"颜色"+"\t"+"价格");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).brand+"\t"
           			 +list.get(i).color+"\t"+list.get(i).price);
        }

    }