java面向对象

最新推荐文章于 2022-11-21 22:29:45 发布

Adopat

最新推荐文章于 2022-11-21 22:29:45 发布

阅读量177

点赞数

分类专栏： java 基础复习

本文链接：https://blog.csdn.net/weixin_44446122/article/details/105104698

版权

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

5 篇文章 0 订阅

订阅专栏

面向对象

面向对象和面向过程的区别
- 面向过程：当要实现一个功能的时候，每一个具体步骤都要亲历亲为，详细处理每一个细节
- 面向对象:类似包工头，我不关心项目实施的每一个步骤，我只关心项目的结果。
- 两者的区别：面向对象强调的是对象，面向过程强调步骤
面向对象的特点：将复杂事务简单化，从执行者变成指挥者，面向对象的语言中，包含了三大基本特征，即封装，继承和多态。

--Demo01PrintArray
public class Demo01PrintArray {
    public static void main(String[] args) {
        //分别使用面向过程和面向对象按照指定的格式输出一个数组
        int[] arr = {10, 20, 30, 40, 50};
        //使用面向过程输出指定格式的数组
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==(arr.length-1)){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }

        }
        System.out.println();
        System.out.println("=================");
        //使用面向对象输出指定的格式
        //找一个java提供给我们的类
        //其中有一个toString()方法
        System.out.println(Arrays.toString(arr));
    }
}

类和对象

类

类是一组相关属性和行为的集合，可以看成是一类事务的模板，使用事务的属性特征和行为特征来描述该类事务。现实中描述一个事务：
- 属性：就是该事务的状态信息
- 行为：就是该事务可以做什么

对象

对象是一类事务的具体体现，对象是类的一个实例

类和对象的关系

类是对一类事务的描述，是抽象的
对象是一类事务的实例，是具体的

类是对象的模板，对象是类的实体。

以手机进行举例：
手机的设计图纸就是类的，这是抽象的
具体设计出来的手机就是对象，对象是类的实例化的结果，类是对象的模板，我们根据模板创建对象。

事务和类的对比

现实中的一类事物
- 属性：事务的状态信息
- 行为：事务能够做什么
java中的类
- 成员方法：定义在类中，对应事务的属性
- 成员方法：对应事务的行为

类的定义格式

public class ClassName{
//成员变量
//成员方法
}

定义类：就是定义类的成员变量和成员方法
成员变量：定义在类中
成员方法：没有static关键字

对象的创建和使用

导包

导包的格式：
import 包名称.类名称;
注意如果和当前类属于同一包，则导包的语句可以省略不写

创建对象

创建对象的格式：
类名称 对象名=new 类名称();

对象分别调用成员变量和成员方法

对象调用成员方法的格式：
对象名.成员方法();
对象调用成员变量的格式:
对象名.成员变量;

对象创建和使用的举例：

--创建Student类
--Student.java
public class Student {
    //定义成员变量
    String name;
    int age;
    char num;
    boolean sex;
    float score;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }

}
--2.创建stu对象
--Deomo02Student.java
/*
* 定义一个学生类
* 属性：姓名,年龄
* 行为：吃饭，学习，睡觉
* 对应Javade 类
* 成员变量：成员变量是直接定义在类中的
* 成员方法：没有static关键字
*
* */
public class Student {
    //定义成员变量
    String name;
    int age;
    char num;
    boolean sex;
    float score;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }

}

手机类的练习

--1。创建Phone类
--Phone.java
public class Phone {
    //成员变量：品牌，价格，颜色，
    String brand;
    String color;
    double price;
    //成员方法：打电话，发短信，拍照，上网
    public void call(String who){
        System.out.println("给"+who+"打电话");
    }
    public void sendMessage(){
        System.out.println("群发短信");
    }
}
--2.创建Demo01PhoneOne.java
public class Demo01PhoneOne {
    public static void main(String[] args) {
        //类的实例化，对象创建的格式
        //格式:类名称 对象名=new 类名称();
        Phone one=new Phone();
        System.out.println(one.brand);//String 类型默认为null
        System.out.println(one.color);//String 类型默认为null
        System.out.println(one.price);//double 类型默认为0.0
        System.out.println("==========================");
        one.brand="iphone";
        one.color="black";
        one.price=9999.0;
        System.out.println(one.brand);
        System.out.println(one.color);
        System.out.println(one.price);
        one.call("乔布斯");
        one.sendMessage();
    }
}

一个对象的内存图

具体百度，涉及到三个内存区域：方法栈，对象堆，方法区内存，方法进栈也称压栈，方法出栈也称弹栈

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hXXbNOrn-1585142077236)(C:\myNote\java_learning\一个对象的内存图.PNG)] 在这里插入图片描述

两个对象的内存图

涉及到三个内存区域：栈，堆，方法区，注意堆中的成员方法存储的是成员方法的地址值，方法要执行必须要进栈，方法执行完毕立即出栈，方法区存储的是.class文件，编译过的字节码文件，main方法中逐行执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q4GiTnig-1585142077238)(C:\myNote\java_learning\两个对象的内存图.PNG)] 在这里插入图片描述

两个对象名称指向同一对象内存空间

注意对象名称也称对象的引用名称，所以有的时候我们也称之为两个引用指向同一内存空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Um2b2rVU-1585142077239)(C:\myNote\java_learning\两个引用指向同一内存空间图.PNG)] 在这里插入图片描述

使用对象类型作为方法的参数

注意当一个对象作为参数，传递到方法当中是，实际上传递进去的是对象的地址值，数组，类和对象都是一致的，main方法运行到方法调用时，查找方法区是否存在相关方法，有则进行方法进栈操作，并把参数值传递给方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OZq500Tb-1585142077239)(C:\myNote\java_learning\使用对象类型作为方法的参数图.PNG)] 在这里插入图片描述

使用对象类型作为方法的返回值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3R6rPVDK-1585142077240)(C:\myNote\java_learning\使用对象类型作为方法的返回值图.PNG)] 在这里插入图片描述

局部变量和成员变量的区别

定义的位置不一样，局部变量定义在方法的内部，成员变量定义在类中，方法的外部
作用范围不一样，局部变量只在方法的内部有使用效果，成员变量在整个类中都可以使用
默认值不一样，局部变量没有默认值，如果要使用必须手动进行赋值，成员变量如果没有赋值会有一个默认的初始值，规则和数组一样
内存位置不一样，局部变量位于栈内存，而成员变量位于堆内存

生命周期不一样，局部变量随着方法栈而诞生，随着方法栈而消失，成员变量随着对象创建而诞生，随着对象被垃圾回收而消失

--Demo01VariableDifference.java
public class demo01VariableDifference {
    String name;//成员变量
    public  void method(int a){
        System.out.println(a);//方法的参数也是局部变量，但是在调用的时候必须会赋值，所以这里是可以正常输出的
        int b=20;
        //System.out.println(b);//局部变量要使用必须要赋值
        System.out.println(name);
    }
}

面向对象之封装性

封装性之方法

封装就是将一些细节信息隐藏起来，对于外界不可见
封装性体现在两个方面：方法也是一种封装，其次是是关键字private

封装性，方法其实也是一种封装，private关键字也是一种封装

public class Demo02Method {
    public static void main(String[] args) {
        int[] arr={5,15,25,100};
        int max=getMax(arr);
        System.out.println("最大值"+max);
    }
    //求数组的最大值
    public static int getMax(int[] arr){
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }

        }
        return max;
    }
}

封装性之private关键字

private关键字

一但使用了private 进行修饰，那么本类中仍然可以随意访问，但是超出了本类，就不能直接访问了，简介访问private 成员变量就是设置一对Setter Getter 方法，其中set方法有参数没有返回值，get方法有返回值，没有参数，set方法用于向成员变量设置数据，get用于数据的提取
对于Getter来说不能有参数，返回值类型必须和成员变量对应
对于Setter来说，不能有返回值，参数类型必须和成员变量对应

--定义Person 类
package cn.itcast.day06.demo03;

public class Person {
    //定义成员变量
    String name;
    private int age;
    //定义成员方法
    public void show(){
        System.out.println("my name is "+name+",age is "+age);
    }
    public void setAge(int num){
        if(age<100 && age>0){
            age=num;
        }else{
            System.out.println("data is wrong!!")
        }
        
    }
    public int getAge(){
        return age;
    }
}
--定义Demo03Person.java
package cn.itcast.day06.demo03;

public class Demo03Person {
    public static void main(String[] args) {
        //定义一个对象
        Person person=new Person();
        person.show();
        person.name="Justin";
        //因为age成员变量使用了private 进行修饰，所以如果要直接使用的话会报错，因该间接使用get set 方法
        person.setAge(18);
        person.getAge();
        person.show();
       // person.age=20;
        person.show();
       // person.age=-18;
        person.show();
    }
}

对于基本数据类型中的boolean类型，Getter方法一定要写成isXXX形式，而setXX方法名成不变

--定义一个Student.java
public class Student {
    private String name;
    private int age;
    private boolean male;
    public void setMale(Boolean sex){
        male=sex;
    }
    public Boolean isMale(){//注意对于基本数据类型boolean，get方法是isXX
        return male;
    }
    //定义对应的成员变量的get set 方法
    public void setName(String str){
        name=str;
    }
    public String getName(){
        return name;
    }
    public void setAge(int num){
        age=num;
    }
    public int getAge(){
        return age;
    }
}
--Demo04Student

public class Demo04Studeng {
    public static void main(String[] args) {
        //定义一个Student 对象
        Student student=new Student();
        student.setAge(18);
        student.setName("justin");
        student.setMale(true);
        System.out.println("name "+student.getName()+" age "+student.getAge()+" male "+student.isMale());//name justin age 18 male true
    }
}

this 关键字

当方法的局部变量和类的成员变量重名的时候，根据就近原则，优先使用的是局部变量，如果需要使用成员变量则需要使用this关键字

通过谁调用的方法，谁就是this，一般来说都是调用方法的对象，this 也指当前对象,this 关键字一般写在方法的内部，谁调用此方法，this 就是指的当前调用者

--Person.java
public class Person {
    String name;
    public void sayHello(String name){
        System.out.println("hello "+name+" my name is "+name);//注意这里的第二个name，我是想使用成员变量name
    }
}
--Demo01Person.java
public class Demo01Person {
    public static void main(String[] args) {
        Person person=new Person();
        person.name="justin";
        person.sayHello("son");//根据就近原则优先使用的是局部变量的名字
    }
    }
    
/

--person.java
public class Person{
	String name;
	public void sayHello(String name){
		System.out.println("hello "+name " my name is "+this.name);//使用this 关键字后this.name 代表的是成员变量的值
	}
}
--Demo01Person.java
public class Demo01Person{
	public static void main(String[] args){
		//定义对象person
		Person person=new Person();
		person.name="王健林"
		person.sayHello("王思聪")//hello 王思聪 my name is 王健林
	}
}

构造方法

构造方法是专门用来创建对象的方法，我们通过关键字new来创建对象的时候，其实就是在调用构造方法
构造方法中要注意的事项：
1. 构造方法中不能有return 值，之前讲过如果返回值是void类型，我们建议使用return 关键字来代表方法的结束，但是在构造方法中return 关键字不能使用
2. 如果没有编写任何构造方法，那么编译器将会有一个创建一个默认的构造方法，没有参数，方法体为空
3. 如果至少有一个构造方法，那么编译器将不会默认创建无参的构造方法，如果需要使用无参的构造方法需要自己格外创建
4. 无参构造方法和带参数类型的构造方法是一种方法的重载的形式，方法重载指的是方法名称一样，参数列表不一样

构造方法的格式

public 类名称(参数类型 参数名称){
	方法体
}
注意事项：
1.构造方法的名称必须和所在类的名称完全一样，就连大小写也要一样
2.构造方法不要写返回值的类型，连void 也不需要

构造方法的使用

--Studnt.java
public class Studnt{
	public Student(){
		System.out.println("构造方法被调用了")
	}
}
--Demo01Student
public class Demo01Student{
	public static void main(String[] args){
		Student student=new Student();//构造方法被调用了
	}
}

无参构造和带参构造的区别

带参构造可以将成员变量，作为方法的参数，在调用的时候不用使用set 方法对成员变量进行赋值
无参构造方法和有参构造方法属于方法的重载
如果需要使用改变成员变量的内容这个时候set方法就派上用途了

--Student.java
public class Student{
	//成员变量
	String name;
	int age;
	//无参的构造方法
	public Student(){
		System.out.println("无参构造方法被调用");
	}
	//带参的构造方法
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	//标准的setter getter 方法
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
}
--Demo01Student.java
public Demo01Student{
	public static void main(String[] args){
		Student student=new Student();//无参构造方法被调用
		Student student1=new Student("justin",18);//带参构造方法被调用
	}
}

定义一个标准的类

一个标准的类通常由四个组成部分

所有的成员变量都要使用private 关键字修饰
为每一个成员变量编写一对Getter/Setter方法
编写一个无参的构造方法
编写一个带有全部参数的构造方法

这样的标准类也叫java bean

--Student
public class Student{
	private String name;
	private int age;
	public Student(){
	
	}
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
}
--Demo01Student.java
public class Demo01Student {
    public static void main(String[] args) {
        Student stu=new Student("dilireba",21);
        System.out.println("name :"+stu.getName()+" age "+stu.getAge());
    }
}

API的使用

概述：应用程序接口，java api 是一本程序员字典，是JDK中提供给我们的使用类的说明文档，这些类将底层的代码封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。
api的使用步骤：
1. 打开帮助文档
2. 点击显示，找到索引，看到输入框
3. 输入需要查找的内容
4. javalang下的类不需要导包，其他需要
5. 看类的解释和说明
6. 学习构造方法
7. 使用成员方法

Scanner类

功能：可以实现键盘输入数据，到程序中。

引用类型的数据的一般使用步骤

导包

import 包路径.类名称
如果使用的目标类和当前类位于同一个包下，则可以省略导包语句不写
只有java.lang包下的内容不需要导包，其他的包都需要import语句
导包语句的快捷键，alt+enter,将鼠标光标放在对应的类名上

创建
```
类名称 对象名=new 类名称();
```
使用
```
对象名.成员方法名();
```

Scanner类的使用

import java.util.Scanner;//导包语句

public class Demo01Scanner {
    public static void main(String[] args) {
        //2创建对象
        //System.in 代表键盘输入
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();//获取键盘输入的整数
        System.out.println(num);//打印键盘输入的整数
        String str=sc.next();//获取键盘输入的字符串
        System.out.println(str);//打印
    }
}
注意其实我们在键盘输入的都是字符串，nextInt()只不过是把你输入的字符串转为整型了而已，具体可以看python中的print()方法

Scanner类的练习

键盘输入两个数，并对之求和运算
import java.util.Scanner;
/*
键盘输入两个整数，并对之求和
 */
public class Demo02Scanner {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //输入的第一个整数
        int num=sc.nextInt();
        int num1=sc.nextInt();
        int sum=num1+num;
        System.out.println(sum);
    }
}
//
利用键盘输入的三个数求最大值
import java.util.Scanner;
public class Demo03ScannerMax {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("please input first number: ");
        int num=sc.nextInt();
        System.out.println("please input second number: ");
        int num1=sc.nextInt();
        System.out.println("please input third number: ");
        int num2=sc.nextInt();
        int tem=num>num1?num:num1;
        int max=tem>num2?tem:num2;
        System.out.println("the max number :"+max);
    }
}

java中的匿名对象

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符,格式：new 类名称();

注意匿名对象只能使用唯一的一次，下次在用不得不在创建一个新的对象，使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象，匿名对象每使用一次就会创建一次

--Person.java
public class Person {
    String name;
    public void myName(){
        System.out.println("my name is :"+name);
    }
}
--Demo01Anomymous.java
public class Demo01Anomymous {
    public static void main(String[] args) {
        Person one=new Person();
        one.name="justin";//my name is :justin
        one.myName();
        //创建一个匿名对象
        new Person().name="paul";
        new Person().myName();//my name is :null,


    }
}

匿名对象作为方法的参数

import java.util.Scanner;

public class Demo02Anomymous {
    public static void main(String[] args) {
  //普通使用的方式
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        System.out.println("the num is :"+num);
        //匿名对象的使用方式
        int num1=new Scanner(System.in).nextInt();
        System.out.println("the num1 is :"+num1);
        //一般的方法使用匿名对象作为方法的参数
        Scanner sc1=new Scanner(System.in);
        methodParam(sc);
        //使用匿名对象做为方法的参数的使用方法
        methodParam(new Scanner(System.in));
        System.out.println("method Return is running");
        int num2=methodReturn().nextInt();
        System.out.println("the num2 is :"+num2);
        System.out.println("method return 2 is running");
        Scanner sc2=methodReturn();
        int num3=sc2.nextInt();
        System.out.println("the num3 is :"+num3);

    }
    public static void methodParam(Scanner sc){
        int num=sc.nextInt();
        System.out.println("the num is :"+num);
    }
    //使用匿名对象作为方法的返回值
    public static Scanner methodReturn(){
        //一般的写法
        Scanner sc=new Scanner(System.in);
        return sc;

    }
    public static Scanner methodParam1(Scanner sc){
        return new Scanner(System.in);
    }
}

Random类概述和基本使用

Random 类是用来生成随机数字，使用起来也是三个步骤
1. 导包 import java.util.Random;
2. 创建 Random r=new Random();
3. 使用 int num=r.nextInt();获取一个随机的int 数字，范围是int 所有范围，有正负两种，大概是±21亿左右

import java.util.Random;

public class Demo01Random {
    public static void main(String[] args) {
        Random r =new Random();
        int num=r.nextInt();
        System.out.println("the num is :"+num);
    }
}

Random 生成指定范围的数据，使用成员方法nextInt(int n);注意n,代表[0,n)

import java.util.Random;
public class Demo01Random {
    public static void main(String[] args) {
        Random r =new Random();
        int num=r.nextInt();
        System.out.println("the num is :"+num);
        //Random 生成指定范围的数据，使用nextInt(int n)
        for (int i = 0; i <100 ; i++) {
            int num1=r.nextInt(10);
            System.out.println(num1);

        }
    }
}

Random 练习题

Random 生成1-n的数字
import java.util.Random;
/*
* 获取1-10的数据
* */
public class Demo03Random {
    public static void main(String[] args) {
        Random r=new Random();
        for (int i = 0; i <100 ; i++) {
          int num= r.nextInt(10)+1;
            System.out.println(num);

        }
    }
}
//
Random 猜字小游戏
import java.util.Random;
import java.util.Scanner;

/*
用代码模拟猜数字的小游戏
思路：

 */
public class Demo04Random {
    public static void main(String[] args) {
        Random r=new Random();
        int i = r.nextInt(100)+1;//1.获取一个1-100的随机数字
        System.out.println("you guess num is :"+i);
        Scanner sc=new Scanner(System.in);
        while(true){
            System.out.println("please input you guess number:");
            int i2 = sc.nextInt();//2.获取键盘输入的数字
            if(i2<i){
                System.out.println("you guess is too low ,please try it again!!");//3.猜的数字太小
            }else if(i2>i){
                System.out.println("you guess is too high ,please try it again!!");//4.猜的数字太大
            }else{
                System.out.println("congratelations you guess is correct");//5.猜对了跳出循环，使用break语句跳出循环
                break;
            }
        }
        System.out.println("the game is over");
    }
}

对象数组

数组的不足

/*
题目:创建一个数组存放三个person 对象
数组可以存放任何数据
但是数组有一个缺点，一旦创建，程序运行期间长度不可改变
*/

public class Demo01Array {
    public static void main(String[] args) {
        //创建一个长度为3的数组,存放person对象,注意使用动态方法创建数组的时候，有默认值，引用值的默认值是null
        Person[] array=new Person[3];
        System.out.println(array[0]);//null
        Person one=new Person("justin",18);
        Person two=new Person("judy",19);
        Person three=new Person("babay",20);
        //将对象放进数组
        array[0]=one;
        array[1]=two;
        array[2]=three;
        System.out.println(array[0]);//存放的是地址值
        System.out.println(array[1]);
        System.out.println(array[2]);
        Person person=array[1];
        System.out.println(person.getName());//"judy"
        System.out.println(array[0].getAge());
    }
}

集合

数组的长度不可以发生改变，但是ArrayLis长度是可以随意发生变化的

ArrayList的基本使用

import java.util.ArrayList;
/*
* 对于ArrayList 来讲有一个<E>代表泛型，
* 泛型，也就是装在集合中的元素都是统一的类型、注意泛型只能是引用类型，不能是基本的数据类型(字符串，数组，类。lambda)
*对于ArrayList集合来说，直接打印的到的不是地址值，而是内容，如果内容为空得到的是[]
* 如果向ArrayList集合中添加的数据不是泛型所规定的引用类型的数据，那么程序，将会发生错误
* */
public class Demo02ArrayList {
    public static void main(String[] args) {
        //创建一个集合，存放String 类型
        //备注从jdk1.7+后，右侧尖括号可以不写内容，但是<>不能少
        ArrayList<String> arr=new ArrayList<>();
        System.out.println(arr);//[]
        //向集合中添加一些数据：使用add方法
        arr.add("justin");
        arr.add("judy");
        System.out.println(arr);//[justin, judy]
    }
}

ArrayList的常用方法

public boolean add(E e):向集合中添加元素，参数的类型和定义集合的时候泛型类型一致,返回值类型代表是否添加成功，备注对于ArrayList 来说，add添加动作是一定成功的，所以返回值可用可不用，但是对于其他集合来说，add添加动作是不一定成功的
public E get(int index):从集合中获取元素，参数是索引编号，从0开始，E代表泛型，就是你定义集合的类型
public E remove(int index):从集合中删除元素，参数是索引编号
public int size():获取集合的尺寸长度，返回值是集合中包含的个数

public class Demo03ArrayListMethod {
    public static void main(String[] args) {
        //定义一个存放String 类型的集合
        ArrayList<String> list=new ArrayList<>();
        //向集合中添加元素
        boolean suceess=list.add("justin");
        System.out.println("add is true?"+suceess);
        list.add("babay");
        list.add("judy");
        System.out.println(list);
        System.out.println("=======================");
        //读取集合中的元素
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println("=======================");
        //删除集合中的元素
        String whoRemove = list.remove(0);
        System.out.println("who is remove: "+whoRemove);
        System.out.println(list);
        System.out.println("=======================");
        //获取集合的长度
        System.out.println(list.size());
        System.out.println("=======================");
    }
}

遍历集合中的元素，注意和array 中的区别，array中的获取长度没有(),还是获取每一个元素的方法也是不一样的

import java.util.ArrayList;

/*
* 遍历集合中的元素
* list.fori
* */
public class Demo04ArrayListEach {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("justin");
        list.add("honey");
        list.add("baby");
        list.add("judy");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));//

        }
    }
}

ArrayList存放基本数据类型

import java.util.ArrayList;

/*
* 之前我们讲过ArrayList中只能使用引用类型的数据，那么是不是就不能存放基本数据类型呢？？
* 我们可以利用包装类将基本数据转换为基本的数据类型，包装类从jdk1.5 开始支持自动装箱和自动拆箱，以下是包装类和基本数据类型的对应关系
* 基本数据类型        包装类(java.lang包下)
* byte               Byte
* short              Short
* int                Integer[特殊]
* long              Long
* float             Float
* double            Double
* char              Character[特殊]
* boolean           Boolean
*
*
* */
public class Demo05ArrayListBasic {
    public static void main(String[] args) {
        //定义一个集合存放基本数据类型char
        ArrayList<Character> listA=new ArrayList<>();
        listA.add('A');
        listA.add('B');
        System.out.println(listA);//[A, B]
        System.out.println(listA.get(1));//B
    }
}

ArrayList练习题

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

/*
* 题目:
* 生成6个1-33之间的随机数，添加到集合，并遍历集合
*
* */
public class Demo01ArrayListRandom {
    public static void main(String[] args) {
        Random r=new Random();
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<6;i++){
            int num=r.nextInt(33)+1;
            list.add(num);
        }
        System.out.println(list);
        System.out.println("==========");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
///
import java.util.ArrayList;
/*
定义一个集合存放四个学生对象
*/
public class Student {
    private String name;
    private int age;

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

    public Student() {

    }
    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;
    }
}
///
public class Demo02ArrayListStudent{
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        Student one=new Student("justin",18);
        Student two=new Student("justin",18);
        Student three=new Student("justin",18);
        Student four=new Student("justin",18);
        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);
        for (int i = 0; i < list.size(); i++) {
            Student stu=list.get(i);
            System.out.println(stu.getAge()+stu.getName());
        }


    }
}
///
//题目：{元素1@元素2@元素3}，改变元素的打印方式。改变集合的打印方式
import java.util.ArrayList;
/*
* 定义方法的三要素
* 返回值的类型：只是进行打印而已，没有运算，没有结果，所以使用void
* 方法名称:printArrayList
* 参数列表：ArrayList
*
* */
public class Demo03ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("justin");
        list.add("jusdy");
        list.add("babay");
        list.add("jack");
        list.add("poney");
        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.print(name+'}');
            }else{
                System.out.print(name+'@');
            }


        }
    }
}
/
/*
* 题目:
* 用一个大集合存放20个随机数字，然后筛选其中的偶数元素，放到小集合中
* 要求使用自定义的方法来进行筛选
*
* */
public class Demo04ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> listA=new ArrayList<>();
        Random r=new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;
            listA.add(num);
        }
        System.out.println(listA);
        System.out.println("========");
        ArrayList<Integer> smallList=returnArrayList(listA);
        System.out.println(smallList);
    }
    //定义一个方法，筛选集合中的偶数
    public static ArrayList<Integer> returnArrayList(ArrayList<Integer> list){
        ArrayList<Integer> listB=new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            int num=list.get(i);
            if(num%2==0){
                listB.add(num);
            }
        }
        return listB;
    }
}

字符串的概述和特点

java.lang.String类代表字符串
API文档说，java程序中所有的字符串字面值（如“abc”）都作为此类的实现，其实就是说，程序中所有的双引号字符串，都是String类的对象(就算没有new ，也照样是)

字符串的特点：

字符串内容永不可变
正是因为字符串不可改变，所以字符串是可以共享使用的
字符串效果上相当于char[]字符数组，但是底层原理是byte[] 字节数组

字符创建的方式和构造方法

/*
* 创建字符串的3+1的方法
* String 类的构造方法
* 1.public String():创建一个空白字符串，不含有任何内容
* 2.public String(char[] array):根据字符数组的内容，创建对应的字符串
* 3.public String(byte[] array):根据字节数组的内容，创建对应的字符串
* 一种直接创建的方式:
*String str="justin";
* 注意直接写上双引号，就是字符串对象
* */
public class Demo01String {
    public static void main(String[] args) {
        //1.使用空参构造方法
        String str1=new String();//小括号留空，说明字符串什么内容都没有
        System.out.println("the first string is :"+str1);
        //2.根据字符数组创建字符串
        char[] charArray=new char[]{'A','B','C'};//使用静态方法创建一个字符数组
        String str2=new String(charArray);
        System.out.println("the second string is :"+str2);
        char[] charArray2={'c','d','e'};
        String str3=new String(charArray2);
        System.out.println("the third string is :"+str3);
        //3.根据字节数组创建字符串
        byte[] byteArray=new byte[]{97,98,99};
        String str4=new String(byteArray);
        System.out.println("the four string is :"+str4);
        //直接创建的方式
        String str5="justin";
        System.out.println("the five string is :"+str5);

    }

}

字符串的常量池

字符串常量池，程序中直接写上的双引号字符串，就存在于字符串常量池中
对于基本数据类型来说，是进行的数值的比较，但是对于引用类型来说是进行地址值的比较

字符串常量池的介绍

public class Demo02StringPool {
    public static void main(String[] args) {
        String str1="abc";
        String str2="abc";
        char[] array={'a','b','c'};
        String str3=new String(array);
        System.out.println(str1==str2);//true
        System.out.println(str1==str3);//false
        System.out.println(str2==str3);//false
    }
}

字符串常量池的内存图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AwPFjxrs-1585142077242)(C:\myNote\java_learning\字符串常量池内存图.PNG)]
字符串的比较相关方法
- equals
- equalsIgnoreCase()：忽略大小写进行比较

/*
* ==是进行对象地址值的比较，如果确实需要字符串内容的比较，可以使用两个方法：
* public booolean equals (Object obj);参数是任何对象，只有参数是一个字符串且内容相等的时候才会返回true,否则返回false
* 注意事项：
* 1.任何对象都可以使用Object进行接收
* 2.equals 方法具有对称性，也就是a.equals(b) 和b.equals(a)在效果上是一样的
* 3.如果比较双方一个常量和一个变量，推荐把常量字符串写在前面
* 推荐 "abc".equals(str1) 不推荐 str1.equals("abc")---这种写法会导致空指针异常
*public boolean equalsIgnoreCase(String str):或略大小写进行比较
*
*
* */
public class Demo01StringEquals {
    public static void main(String[] args) {
        String str1="abc";
        String str2="abc";
        char[] array={'a','b','c'};
        String str3=new String(array);
        System.out.println(str1.equals(str2));//true
        System.out.println(str1.equals(str3));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals("abc"));//true
        System.out.println("abc".equals(str1));//true
        System.out.println("====================================");
        String str4="abc";
        System.out.println("abc".equals(str4));//true【推荐写法】
        System.out.println(str4.equals("abc"));//true【不推荐】
        //在以下情况导致空指针异常
        String str5=null;
        System.out.println("abc".equals(str5));//false
       // System.out.println(str5.equals("abc"));//NullPointerException,地址值为null 导致的空指针异常
        System.out.println("===================================================================");
        //使用equalsIgnoreCase()进行字符串的比较，此方法可以忽略大小写
        String str6="ABc";
        char[] arr=new char[]{'a','b','C'};
        String str7=new String(arr);
        System.out.println(str6.equals(str7));//false
        System.out.println(str6.equalsIgnoreCase(str7));//true

    }
}

字符串的相关方法

public int length():获取字符串当中的字符个数，拿到字符串的长度
public String concat(String str):将当前字符串和参数列表字符串进行拼接，成为返回值字符串
public char charAt(int index):获取指定索引位置的单个字符。(索引从0开始)
public int indexOf(String str):查找参数字符串在本字符串中首次出现的位置，如果没有返回-1值。

public class Demo02StringGet {
    public static void main(String[] args) {
        //public int length():获取字符串的长度
        String str1="justin";
        int lenth=str1.length();
        System.out.println("the string's length is :"+lenth);//6
        //public String concat(String str):字符串的拼接
        String str2=str1.concat(" hello");
        System.out.println("the string concat is :"+str2);//justin hello
        //public char charAt(int index):获取指定位置的单个字符
        char c=str1.charAt(1);
        System.out.println("the second char is :"+c);//u
        //public int indexOf(String str):获取指定字符串在本字符串中首次出现的位置
        int num=str1.indexOf("in");
        System.out.println("in first occur at :"+num);//4
        int num1= str1.indexOf("ppp");
        System.out.println("ppp first occur at :"+num1);//-1,没找到返回-1
    }
}

public String substring(int index):截取从参数位置的一直到字符串末尾，返回新字符串
public String substring(int begin,int end):从begin 开始位置进行截取，一直到end 结束位置，注意是个左闭右开区间，包含左边的数值，不包含右边的数值

public class Demo03Substring {
    public static void main(String[] args) {
        String str1="helloworld";
        String str2=str1.substring(5);
        System.out.println("截取后的字符串是 ："+str2);
        System.out.println("==================================");
        String str3=str1.substring(4,7);
        System.out.println("显示 owo 吗？ ："+str3);
        System.out.println("=====================");
        //下面这种写法，字符串的内容仍然是没有变化的
        //下面有两个字符串，strA保存的是地址值，改变的只是地址值
        String strA="hello";
        System.out.println(strA);
        String strB="java";
        System.out.println(strB);
    }
}

public char[] tocharArray():将当前字符串拆分为字符数组作为返回值
public byte[] getBytes():获得当前字符串的底层的字节数组
public String replace(CharSequence oldString,CharSequence newString):将所有出现的老字符串替换成新的字符串，返回替换之后的结果新字符

public class Demo04StringConvert {
    public static void main(String[] args) {
        String str1="hello";
        char[] chars=str1.toCharArray();
        System.out.println(chars);//字符数组打印为何出现字符串，这是因为println（）方法对字符数组进行了重载，
        // System.out 是一个 PrintStream 对象，你看看文档，有 print(char[]) 和 println(char[]) 方法，但没有 print(int[]) 或者 println(int[]) 方法。
        //所以 PrintStram 是专门针对 char[] 写了个方法的，能打印出来字符也不是啥怪事了。
        int[] num={1,2,3,4,5};
        System.out.println(num);//地址值
        System.out.println(chars.length);
        //转换为字节数组
        byte[] bytes="abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("==============================");
        //字符串的替换
        String str2="我日你大爷的！！！会不会完啊！";
        String str3=str2.replace("日","*");//我*你大爷的！！！会不会完啊！
        System.out.println(str3);
        System.out.println("===============");
        //字符串的截取
        String str4="我是你爸爸！！";
        String str5=str4.substring(0,1);
        System.out.println(str5);//我
    }
}

public String[] split(String regex):按照参数规则，将字符串切分为若干部分

public class Demo05StringSplit{
    public static void main(String[] args) {
        //字符串的切割，public String[] split(String regex):注意返回的是一个字符数组,注意regex 代表是正则表达式，而英文句点.
        //英文句点.在正则表达式中有特殊的含义，要使用转义字符\\.来表示句点.
        String str1="hello,world,java";
        String[] arr = str1.split(",");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("==========================");
        //使用空格进行切分
        String str2="aaa bbb ccc";
        String[] arr2 = str2.split(" ");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        System.out.println("================================");
        String str3="aaa.bbb.ccc";
        String[] arr3 = str3.split("\\.");//单独写点.字符切割会失败
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
    }
}

字符串的练习题

定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串，格式参考如下：[world1#world2#world3]。


public class Demo06StringPractice {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3};//静态初始化一个整型数组
        String result=fromArrayToString(arr);
        System.out.println(result);
    }

    public static String fromArrayToString(int[] arr) {
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                str += "world" + arr[i] + "#";

            } else {
                str += "world" + arr[i] + "]";
            }

        }
        return str;

    }
}

键盘输入一个字符串，并统计其中各种字符出现的次数，种类有：大写字母，小写字母，数字和其他

import java.util.Scanner;

public class Demo07StringCount {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);//定义Scanner对象
        System.out.println("请输入一个字符 ：");
        String input=sc.next();//定义一个字符串接受键盘输入的数字
        int countUpper=0;//大写字母
        int countLower=0;
        int countNumber=0;
        int countOther=0;
        //将字符串装为字符数组
        char[] charArray=input.toCharArray();
        //遍历字符数组
        for (int i = 0; i < charArray.length; i++) {
            char ch=charArray[i];
            if(ch>='A'&&ch<='Z'){//char byte 在进行运算的时候会上升到byte 进行运算，所以可以使用四则运算符
                countUpper++;
            }else if(ch>='a'&&ch<='z'){
                countLower++;
            }else if(ch>='0'&&ch<='9'){
                countNumber++;
            }else{
                countOther++;
            }
        }
        System.out.println("大写字母有 ："+countUpper);
        System.out.println("小写字母有 ："+countLower);
        System.out.println("数字有 ："+countNumber);
        System.out.println("其他有 ："+countOther);
    }
}

静态关键字static的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6wXeQkou-1585142077243)(C:\myNote\java_learning\static关键字.PNG)]

static 修饰成员变量

如果一个成员变量使用了static关键字，那么这个变量不在属于对象自己，而是属于所在的类，多个对象共享同一份数

//Student.java
public class Student {
    private int id;//学生的学号，实现学号进行自增
    private String name;
    private int age;
    static String room;//所在教室
    private static int idCounter=0;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id=++idCounter;//每次创建id++,注意如果这里写成后++,呢么学号就从0号开始了
    }

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

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}
//Demo01StaticField.java
public class Demo01StaticField {
    public static void main(String[] args) {
        Student one=new Student("郭靖",18);
        Student two=new Student("黄蓉",19);
        one.room="B栋101";
        System.out.println("姓名 ："+one.getName()+" 年龄 ："+one.getAge()+" 教室 ："+one.room+" 学号 ："+one.getId());//姓名 ：郭靖 年龄 ：18 教室 ：B栋101 学号 ：1
        System.out.println("姓名 ："+two.getName()+" 年龄 ："+two.getAge()+" 教室 ："+two.room+" 学号 ："+two.getId());//姓名 ：黄蓉 年龄 ：19 教室 ：B栋101  学号 ：2 多个对象共享共享同一份数据//推荐使用类名调用静态变量

    }
}

static修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类的，如果没有static关键字，那么必须首先创建对象，然后通过对象才能调用成员方法。
对于静态方法来说可以通过对象名来调用，也可以通过类名来调用，不过我们一般推荐使用类名来调用。
无论是成员变量还是成员方法，如果有了static，都推荐使用类名进行调用，静态变量：类名.静态变量静态方法：类名.静态方法
注意事项：
- 静态不能直接访问非静态，原因是在内存中是先有的静态内容，后有的非静态内容“先人不知道后人，但是后人知道先人”
- 静态方法中不能使用this 关键字，原因是this 代表的是当前对象，通过谁调用的方法，谁就是当前对象

//MyClass.java
public class MyClass {
    int num;
    static int numStatic;
    public void method(){
        System.out.println("这是一个成员方法.");
        System.out.println(num);//可以成功调用
        System.out.println(numStatic);//可以成功调用
    }
    public static void methodStatic(){
        System.out.println("这是一个静态方法.");
        System.out.println(numStatic);//可以调用
        //System.out.println(num);//调用失败
        //System.out.println(this);//写法错误
    }
}
//Demo02StaticMethod.java
public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj=new MyClass();
        obj.method();
        obj.methodStatic();//静态方法不推荐使用对象名来进行调用,这种写法也会被javac编译成“类名称.静态方法”
        MyClass.methodStatic();//推荐使用类名来调用
        myMethod();//对于本类的静态方法，可以省略类名称，其实在编译的时候还是会装为类名称.静态方法
        Demo02StaticMethod.myMethod();//完全等效
    }

    public static void myMethod(){
        System.out.println("自己的方法！！");
    }
}

static的内存图

[外链图片转存失败,站可能有防盗链机制,建议将图片保存下来直接上传(img-1cTXhg4O-1585142077244)(C:\myNote\java_learning\static内存图.PNG)]

静态代码块

静态代码块的格式

public class 类名称{
	static{
		//静态代码块内容
	}
}
//特点：当第一次用到本类的时候，静态代码块执行唯一的一次，静态内容总是优先于非静态，所以静态代码块比构造代码块先执行
//静态代码块的典型用途：
//用来一次性的对静态成员变量进行赋值。

//Person.java
public class Person {
    public Person(){
        System.out.println("无参构造方法被执行");
    }
    static {
        System.out.println("静态代码块执行！！");
    }

}
//Demo04Static.java
public class Demo04Static {
    public static void main(String[] args) {
        Person one=new Person();//静态代码块执行！！
        //无参构造方法被执行
        Person two=new Person();//无参构造方法被执行

    }
}

数组工具类Arrays

提供了一系列的静态方法供数组调用

public static String toString(数组)：将参数数组变成字符串，按照默认的格式[元素1,元素2,元素3]
public static void sort(数组)：按照默认的升序格式，给数组进行排序操作,默认升序
注意事项：如果是数值，sort默认按照升序从小到大，如果是字符串，sort默认按照字母升序，如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

public class Demo01Arrays {
    public static void main(String[] args) {
        int[] arr={10,20,30};
        //调用Arrays的toString方法将数组转为字符串
        String str= Arrays.toString(arr);
        System.out.println(str);//[10, 20, 30]
        //调用Arrays的sort方法对数组进行排序
        int[] arr1={30,10,2,40,5,90};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));//[2, 5, 10, 30, 40, 90]
        String[] str2={"aaa","bbb","ddd","ccc"};
        Arrays.sort(str2);
        System.out.println(Arrays.toString(str2));//[aaa, bbb, ccc, ddd]

    }
}

Arrays相关练习题

//调用Arrays的相关API，将一个随机字符串的所有字符进行升序排列，并倒序打印
public class Demo02ArraysPractice {
    public static void main(String[] args) {
        String str="askflonbxoamlr";
        //将字符串进行升序，把字符串转为数组，然后调用Arrays 的sort 方法
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对数组进行升序排列
        //倒序输出
        for (int i = chars.length - 1; i >= 0; i--) {//chars.forr  倒序循环，chars.fori
            System.out.println(chars[i]);
        }
    }
}

数学工具类Math

java.util.Math 类是数学相关的工具类，里面提供了大量的静态方法，完成于数学运算的相关操作

// public static double abs(double num):获取绝对值,有多种重载
//public static double ceil(double num):向上取整
//public static double floor(double num):向下取整
//public static long round(double num):四舍五入，注意java中的round()是四舍五入取整，如果要实现保留小数点后几位，可以使用除法/100.0（保留两位小数）
//Math.PI近似的圆周率（double ）
public class Demo03Math {
    public static void main(String[] args) {
        //获取绝对值abs()
        System.out.println(Math.abs(10));//10
        System.out.println(Math.abs(-10));//10
        System.out.println(Math.abs(0));//0
        System.out.println("==============================");
        //向上取整ceil()
        System.out.println(Math.ceil(10.0));//10.0
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(-10.8));//-10(注意-10.8向上取整为-10.0)
        System.out.println(Math.ceil(4.1));//5.0
        System.out.println("==========================");
        //向下取整floor()
        System.out.println(Math.floor(3.8));//3.0
        System.out.println(Math.floor(3.1));//3.0
        System.out.println(Math.floor(3.0));//3.0
        System.out.println("========================");
        //四舍五入round()
        System.out.println(Math.round(10.55));//11
        System.out.println(Math.round(10.66));//11
        System.out.println(Math.round(10.33));//10
        System.out.println(Math.round(10.11111f));//10
        System.out.println(Math.PI);//3.141592653589793

    }
}

Math相关的练习题

//计算-10.8到5.9之间绝对值大于6或者小于2.1的整数有多少个？
public class Demo04MathPractice {
    public static void main(String[] args) {
        double min=-10.8;
        double max=5.9;
        //System.out.println(Math.ceil(min));
        int count=0;
        for(int i=(int)Math.ceil(min);i<max;i++){//注意Math.ceil()的返回值类型是double类型，这里可以直接使用int，强转，但是为了实践Math.ceil()方法多用了一个函数
            int abs=Math.abs(i);
            if(abs>6||abs<2.1){
                count++;
                System.out.println(Math.abs(abs));
            }

        }
        System.out.println("符合条件的数有 ："+count);//9
    }
}

0
System.out.println(Math.abs(-10));//10
System.out.println(Math.abs(0));//0
System.out.println("");
//向上取整ceil()
System.out.println(Math.ceil(10.0));//10.0
System.out.println(Math.ceil(3.9));//4.0
System.out.println(Math.ceil(-10.8));//-10(注意-10.8向上取整为-10.0)
System.out.println(Math.ceil(4.1));//5.0
System.out.println("");
//向下取整floor()
System.out.println(Math.floor(3.8));//3.0
System.out.println(Math.floor(3.1));//3.0
System.out.println(Math.floor(3.0));//3.0
System.out.println("====================");
//四舍五入round()
System.out.println(Math.round(10.55));//11
System.out.println(Math.round(10.66));//11
System.out.println(Math.round(10.33));//10
System.out.println(Math.round(10.11111f));//10
System.out.println(Math.PI);//3.141592653589793

}


- Math相关的练习题

```java
//计算-10.8到5.9之间绝对值大于6或者小于2.1的整数有多少个？
public class Demo04MathPractice {
  public static void main(String[] args) {
      double min=-10.8;
      double max=5.9;
      //System.out.println(Math.ceil(min));
      int count=0;
      for(int i=(int)Math.ceil(min);i<max;i++){//注意Math.ceil()的返回值类型是double类型，这里可以直接使用int，强转，但是为了实践Math.ceil()方法多用了一个函数
          int abs=Math.abs(i);
          if(abs>6||abs<2.1){
              count++;
              System.out.println(Math.abs(abs));
          }

      }
      System.out.println("符合条件的数有 ："+count);//9
  }
}

Adopat

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java面向对象

面向对象面向对象面向对象和面向过程的区别面向过程：当要实现一个功能的时候，每一个具体步骤都要亲历亲为，详细处理每一个细节面向对象:类似包工头，我不关心项目实施的每一个步骤，我只关心项目的结果。两者的区别：面向对象强调的是对象，面向过程强调步骤面向对象的特点：将复杂事务简单化，从执行者变成指挥者，面向对象的语言中，包含了三大基本特征，即封装，继承和多态。--Demo01Pri...
复制链接

扫一扫

专栏目录