Java基础语法_对象数组，封装，构造器，包操作使用

---

1.对象数组

/*
数组是用来存一组数，这组数可以是基本数据类型，也可以是引用数据类型
	int[] arr; 存了一组整数
	char[] arr; 存了一组单字符	
	String[] arr; 存了一组字符串对象
	Student[] arr; 存了一组学生对象
当我们数组中存储了一组对象时，那么我们称为对象数组。	
*/ class Test08_ObjectArray{ public static void main(String[] args){ //要用一个数组，存储5个圆对象，半径分别为1-5 //(1)声明一个数组 //数组的元素的类型是Circle Circle[] arr = new Circle[5];//这个new是创建数组对象 //(2)为数组的元素赋值 for(int i=0; i<arr.length; i++){ //元素：数组名[下标] //arr[i].radius = i+1;//java.lang.NullPointerException  arr[i] = new Circle();//创建圆对象 arr[i].radius = i+1; } //(3)遍历数组，打印每一个圆的信息 for(int i=0; i<arr.length; i++){ //现在的数组的元素arr[i]就是一个圆对象，既然是圆对象，就可以调用圆的属性和方法 arr[i].printInfo(); //System.out.println(arr[i]); } } } class Circle{ double radius; double getArea(){ return 3.14 * radius * radius; } void printInfo(){ System.out.println("半径：" + radius + "，面积：" + getArea()); } } 

/*          
（1）声明一个学生类Student，包含姓名name和成绩score属性
（2）在测试类TestStudentArray中创建一个长度为3的学生数组
（3）从键盘输入为学生对象的姓名和成绩属性赋值
（4）遍历显示学生信息
（5）使用冒泡排序对数组按照学生成绩从低到高排序
（6）再次遍历显示学生信息
*/ class Test09_Exer3{ public static void main(String[] args){ //创建一个长度为3的学生数组 Student[] all = new Student[3]; //从键盘输入为学生对象的姓名和成绩属性赋值 java.util.Scanner input = new java.util.Scanner(System.in); for(int i=0; i<all.length; i++){ System.out.println("请输入第" + (i+1) + "个学员的信息："); //创建这个学生对象 all[i] = new Student(); System.out.print("姓名："); all[i].name = input.next(); System.out.print("成绩："); all[i].score = input.nextInt(); } //遍历显示学生信息 for(int i=0; i<all.length; i++){ //all[i].printInfo(); System.out.println(all[i].getInfo()); } //使用冒泡排序对数组按照学生成绩从低到高排序 for(int i=1; i<all.length; i++){//控制轮数  //从低到高，把大的往右移动 /*
			当i=1, j=0,1  all[0]与all[1]  all[1]与all[2]
			当i=2，j=0    all[0]与all[1]
			all[j] 与 all[j+1]
			*/ for(int j=0; j<all.length-i; j++){ //all[j]是一个学生对象，不能比较大小 //if(all[j] > all[j+1]){//二元运算符 '>' 的操作数类型错误 if(all[j].score > all[j+1].score){ //交换两个元素，不是交换两个人的成绩 Student temp = all[j];//all[j]是一个Student all[j] = all[j+1]; all[j+1] = temp; } } } //遍历显示学生信息 for(int i=0; i<all.length; i++){ //all[i].printInfo(); System.out.println(all[i].getInfo()); } } } class Student{ String name; int score; void printInfo(){ System.out.println("姓名：" + name + "，成绩：" + score); } String getInfo(){ return "姓名：" + name + "，成绩：" + score; } } 

2.封装

/*
一、封装
1、封装的意义：（1）隐藏实现细节（2）安全
2、封装的类型：（1）属性的封装、方法的封装等（2）组件的封装（3）系统的封装
3、封装的实现，靠权限修饰符来控制可见的范围。

权限修饰符：类：缺省或public，如果类前面有public，那么必须与源文件名相同
属性：四种都可以。方法：四种都可以	

4、属性的封装
大多数情况下，属性都是private
如果属性私有化了，我们会提供get/set方法
get/set的标准写法：
	public void set属性名(数据类型 形参名){
		属性名 = 形参名;
	}
	public 属性的数据类型 get属性名(){
		return 属性名;
	}

5、方法的封装：大多数情况下，方法都是public
*/ public class Test10_Encapsulation{ public static void main(String[] args){ //1、创建对象 Circle c1 = new Circle(); //2、为属性赋值 //c1.radius = 1.2;//错误的 c1.setRadius(1.2); System.out.println("半径：" + c1.getRadius()); } } class Circle{ private double radius;//仅限与本类中访问  //radius属性的set方法，用于在其他类中修改radius的值 public void setRadius(double r){ if(r>0){//使得赋值可控 radius = r; } } //radius属性的get方法，用于在其他类中获取radius的值 public double getRadius(){ return radius; } } 

3.构造器

 /*
类的第三个组成部分：构造器，也称为构造方法，因为（1）它长的像方法（2）它编译后是一个实例初始化方法	
1、构造器的作用
（1）构造对象，创建对象，和new一起使用，每次调用它就是在创建新的对象	
（2）可以在创建对象的同时，给属性赋值

2、构造器的特点
（1）所有类都有构造器
（2）如果一个类没有显式声明构造器，那么编译器将会自动生成一个默认的无参构造
（3）如果一个类显式声明了构造器，那么编译器将不会自动生成默认的无参构造了
（4）构造器的名称必须与类名相同
（5）构造器没有返回值类型，也不写void
（6）构造器可以重载

3、构造器的语法结构
	【修饰符】 类名(){		
	}
	【修饰符】 类名(形参列表){		
	}	
	java.util.Scanner input = new java.util.Scanner(System.in);//调用的是有参构造
	int num = input.nextInt();//从键盘输入一个整数	
	java.util.Random rand = new java.util.Random();//调用的是无参构造
	int num = rand.nextInt(10);//产生一个[0,10)的整数
*/ class Test12_Constructor{ public static void main(String[] args){ //创建对象：类名 对象名 = new 类名(); //Circle c = new Circle(); //这里Circle()就是构造器  Circle c = new Circle(1.2);//1.2给半径赋值，在创建对象的同时给属性赋值用的 c.printInfo(); c.setRadius(2.5);//创建对象之后，修改属性值用的 c.printInfo(); Circle c2 = new Circle();//先创建对象，不给半径赋值 c2.setRadius(3.6); c2.printInfo(); } } class Circle{ private double radius; //double r：构造器的形参列表 public Circle(double r){//有参构造 radius = r;//给半径赋值 } public Circle(){//无参构造  } public void printInfo(){ System.out.println("半径：" + radius); } public void setRadius(double r){ radius = r; } } 

/*
1、声明学生类，
（1）有属性：姓名，年龄，成绩，并且私有化，
（2）提供有参和无参构造
（3）提供公共的get/set。
（4）提供getInfo()方法，返回学生对象的信息
2、在测试中
（1）用有参和无参构造分别创建对象
（2）用set方法修改属性值
（3）用getInfo()返回学生信息
类{
	属性列表;	
	构造器列表;	
	方法列表;
}
*/ class Test13_Exer5{ public static void main(String[] args){ //1、无参构造创建对象 Student s1 = new Student(); //s1.setName = "张三";//错误的 s1.setName("张三"); s1.setAge(23); s1.setScore(89); System.out.println(s1.getInfo()); //2、有参构造创建对象 Student s2 = new Student("李四",24, 34); System.out.println(s2.getInfo()); s2.setScore(74);//修改成绩的值 System.out.println(s2.getInfo()); } } class Student{ private String name; private int age; private double score; public Student(){ } public Student(String n, int a, double s){ name = n; age = a; score = s; } //提供公共的get/set。 public void setName(String n){ name = n; } public String getName(){ return name; } public void setAge(int a){ age = a; } public int getAge(){ return age; } public void setScore(double s){ score = s; } public double getScore(){ return score; } public String getInfo(){ return "姓名：" + name + "，年龄:" + age +"，成绩：" +score; } } 

class Day08_Test02{ } class MyArrays{ /*
	1、int  binarySearch(int[]  arr,  int  value)：
		使用二分查找法在arr数组中查找value的下标，
		如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确*/ public int binarySearch(int[] arr, int value){ int left = 0; int right = arr.lenght-1; int mid = (left + right)/2; while(left<=right){ if(arr[mid] == value){ return mid; }else if(value > arr[mid]){ left = mid + 1; }else if(value <arr[mid]){ right = mid -1; } mid = (left + right)/2; } return -1; } /*
	int  copy(int[] arr , int length)：从指定的arr数组的arr[0]
	开始复制得到一个新数组，新数组的长度为length。*/ public int[] copy(int[] arr, int length){ //(1)创建新数组 int[] newArr = new int[length]; //(2)复制元素 for(int i =0; i<arr.length && i<newArr.length; i++){ newArr[i] = arr[i]; } return newArr; } /*
	void sort(int[] arr)：可以给arr数组从小到大排序，用冒泡排序实现
	*/ public void sort(int[] arr){ for(int i=1; i<arr.length; i++){ for(int j=0; j<arr.lenght-i; j++){ if(arr[j] > arr[j+1]){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } } 

如下去掉return，结果为1

class Day08_Test03{ public static void main(String[] args){ int x = 1; x = doubleNumber(x); System.out.println("x = " + x); char c = 'a'; c = toUpperCase(c); System.out.println(c); Circle c1 = new Circle(); c1.radius = 1.0; expandCircle(c1, 5); System.out.println("半径：" + c1.radius); String str = "hello"; str = concatAtguigu(str); System.out.println(str); } /*偷梁换柱
	public static  void  doubleNumber(int x){
		x *= 2;
		System.out.println("x = " + x);
		System.exit(0); //结束整个java程序
	}*/ public static int doubleNumber(int num){ return num*2; } //public static void toUpperCase(char letter){ //	letter = (char)(letter - 32); //} public static char toUpperCase(char letter){ return (char)(letter - 32); } public static void expandCircle(Circle  c,double times){ c.radius *= times; } //尝试在str后面拼接“atguigu"字符串，看是否可以将给str赋值的实参字符串变量也修改了， //为什么，如果不能，那怎么解决？ //不能，因为String类型比较特殊，它的对象是不可变对象，一旦修改（包括拼接）就会产生新对象 //public static void concatAtguigu(String str){ //	str += "atguigu";//str修改后会指向新对象，就不是原来的实参的那个字符串对象了 //} public static String concatAtguigu(String str){ return str += "atguigu"; } } class Circle{ double radius; } 

/*
 	1、声明一个Employee员工类，
 		包含属性：编号(id)、姓名(name)、薪资(salary)、年龄(age)
 		包含方法：
 		（1）void printInfo()：可以打印员工的详细信息
 		（2）void setInfo(int  i, String n, double s, int a)：可以同时给id,name,salary,age赋值
 	2、声明一个TestEmployee测试类，
 	（1）public static void main(String[] args)：
	在main方法中，创建Employee[]数组，并创建5个员工对象放到数组中，
	并为员工对象的属性赋值
 	（2）public static void print(Emplyee[] all)：遍历打印员工数组中的每个员工的详细信息，并在main中调用
 	（3）public static void sort(Employee[] all)：将all员工数组按照年龄从高到低排序，并在main中调用测试
 	（4）public static void addSalary(Employee[] all, double increament)：将all员工数组的每一个员工的工资，增加increament，并在main中调试测试
*/ class Day08_Test05{ public static void main(String[] args){ Employee[] all = new Employee[5]; all[0] = new Employee(); all[0].setInfo(1,"张三",10000,23); all[1] = new Employee(); all[1].setInfo(2,"李四",12000,23); all[2] = new Employee(); all[2].setInfo(3,"王五",8000,18); all[3] = new Employee(); all[3].setInfo(4,"赵六",6000,20); all[4] = new Employee(); all[4].setInfo(5,"钱七",15000,21); print(all); sort(all); System.out.println("------------------------------------------"); print(all); addSalary(all, 200); System.out.println("------------------------------------------"); print(all); } public static void print(Employee[] all){ for(int i=0; i<all.length; i++){ all[i].printInfo(); } } public static void sort(Employee[] all){ for(int i=1; i<all.length; i++){ for(int j=0; j<all.length-i; j++){ //从高到低 if(all[j].age < all[j+1].age){ Employee temp = all[j]; all[j] = all[j+1]; all[j+1] = temp; } } } } public static void addSalary(Employee[] all, double increament){ for(int i=0; i<all.length; i++){ all[i].salary += increament; } } } class Employee{ int id; String name; double salary; int age; void printInfo(){ System.out.println("编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，年龄：" +age); } void setInfo(int i, String n, double s, int a){ id = i; name = n; salary = s; age = a; } } 

/*
 	1、声明矩形类Rectangle
 	（1）包含属性：长和宽，要求属性私有化
 	（2）包含两个构造器：无参和有参
 	（3）给每一个属性提供get/set方法
 	（4）public double getArea()
 	（5）public double getPerimeter()
 	（6）提供getInfo()返回矩形对象的信息：例如：长：2，宽：3，面积：6，周长：10

 	2、测试类TestRectangle
 	编写Test07类，在main方法中
 	（1）创建一个Rectangle[]数组，长度为5
 	（2）并创建5个Rectangle的矩形对象，放到数组中，矩形的长和宽随机生成[0,10.0)范围内的值
 	（3）遍历显示
 	（4）按照面积从小到大排序
 	（5）再次遍历显示
*/ class Day08_Test07{ public static void main(String[] args){ Rectangle[] arr = new Rectangle[5]; for(int i=0; i<arr.length; i++){ arr[i] = new Rectangle(); double d1 = Math.random()*10; double d2 = Math.random()*10; arr[i].setLength(d1>d2?d1:d2); arr[i].setWidth(d1<=d2?d1:d2); } for(int i=0; i<arr.length; i++){ System.out.println(arr[i].getInfo()); } System.out.println("------------------------"); for(int i=1; i<arr.length; i++){ //冒泡 for(int j=0; j<arr.length-i; j++){ if(arr[j].getArea() > arr[j+1].getArea()){ Rectangle temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } for(int i=0; i<arr.length; i++){ System.out.println(arr[i].getInfo()); } } } class Rectangle{ private double length; private double width; public Rectangle(){ } public Rectangle(double chang, double kuan){ length = chang; width = kuan; } public void setLength(double chang){ length = chang; } public double getLength(){ return length; } public void setWidth(double kuan){ width = kuan; } public double getWidth(){ return width; } public double getArea(){ return length * width; } public double getPerimeter(){ return 2 * (length + width); } public String getInfo(){ return "长：" + length + "，宽：" + width + "，面积：" + getArea() + "，周长：" + getPerimeter(); } } 

4.包

/*
1、包的作用：（1）避免类的重名问题，包就是命名空间，避免命名冲突
有了包后，类的名称就比较长了，类的全名称就变为了：包.类名
	java.util.Scanner ：Scanner类的全名称
	java.lang.String：String类的全名称
	java.lang.System：System类的全名称
	java.lang.Math：Math类的全名称
（2）分类组织管理众多的类
java.io：和IO(输入输出)有关
java.util：和各种常用工具类有关
java.lang：核心系统类
java.net：和网络编程有关
java.sql：和数据库编程有关
（3）用于访问权限控制：如果某个类或某个方法的权限修饰符省略，那么就仅限于本包使用

2、如何声明包？语法格式：package 包名;
这句话有要求：
（1）一个.java源文件只能有一句
（2）必须在源文件的代码首行
包名的命名规范：
（1）所有单词都小写，每个单词之间用.分割
（2）习惯上用公司的域名倒置 + 模块名
例如：com.atguigu.xx;
      com.mysql.xxx
	  com.alibaba.xxx
	  org.aphache.xxx	  
一级域名：
		com：商业
		org：非营利性组织
		gov：*
		edu：教育
		....
		
3、如何编译带包的类
了解：
	javac -d . 源文件名.java	
		
4、如何运行带包的类
了解：
	java 包.类名
	
5、如何使用其他包的类
前提：被使用的类或成员的权限修饰符得允许跨包使用
方式：
（1）使用全名称：包.类名
（2）使用import语句 + 简名称	
说明：
①import 语句是写在 package语句与class声明之间的
②导包语句可以很多句，导不同包的类
③java.lang包中类可以不使用import语句，就直接使用简名称。例如：System，String，Math....
④可以同时导入同一个包中的很多类。import 包.*;
⑤如果出现了不同包，但是类名相同。例如：java.util.Date，java.sql.Date
只能一个选择使用全名称，一个使用简名称，不能同时使用简名称
*/ package com.atguigu.pkg; import com.atguigu.bean.*; import java.util.Date; //import java.sql.Date; class Test01_Package{ public static void main(String[] args){ System.out.println("hello pkg"); //用另外一个包的类 Circle c1 = new Circle(1.2); //com.atguigu.bean.Circle c1 = new com.atguigu.bean.Circle(1.2); c1.printInfo(); Rectangle r1 = new Rectangle(); } } 

如下不在ide中自动创建，要自己创建文件夹


如下不用手动创建文件夹

本文地址：https://blog.csdn.net/weixin_43435675/article/details/108030352