面向对象
面向对象
- 面向对象和面向过程的区别
- 面向过程:当要实现一个功能的时候,每一个具体步骤都要亲历亲为,详细处理每一个细节
- 面向对象:类似包工头,我不关心项目实施的每一个步骤,我只关心项目的结果。
- 两者的区别:面向对象强调的是对象,面向过程强调步骤
- 面向对象的特点:将复杂事务简单化,从执行者变成指挥者,面向对象的语言中,包含了三大基本特征,即封装,继承和多态。
--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来创建对象的时候,其实就是在调用构造方法
-
构造方法中要注意的事项:
- 构造方法中不能有return 值,之前讲过如果返回值是void类型,我们建议使用return 关键字来代表方法的结束,但是在构造方法中return 关键字不能使用
- 如果没有编写任何构造方法,那么编译器将会有一个创建一个默认的构造方法,没有参数,方法体为空
- 如果至少有一个构造方法,那么编译器将不会默认创建无参的构造方法,如果需要使用无参的构造方法需要自己格外创建
- 无参构造方法和带参数类型的构造方法是一种方法的重载的形式,方法重载指的是方法名称一样,参数列表不一样
-
构造方法的格式
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的使用步骤:
- 打开帮助文档
- 点击显示,找到索引,看到输入框
- 输入需要查找的内容
- javalang下的类不需要导包,其他需要
- 看类的解释和说明
- 学习构造方法
- 使用成员方法
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 类是用来生成随机数字,使用起来也是三个步骤
- 导包 import java.util.Random;
- 创建 Random r=new Random();
- 使用 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
}
}