m0_45442261

java面向对象oop阶段总结

名词解释

笔记0927
*对象数组起始位置可以初始化几个元素
// 1.功能五判断队名是否重复2.给队起名；3.队伍建队用flag循环判断是否队伍已满；
2.功能六遍历二维数组子元素的方法

*3.Role[] roles = new Role[0];// 建立角色对象数组【只有初始值为0或者初始化元素个数等于数组查高度时采用数组扩容和截取数组；否则用getMax方法获得最大实际长度，增加最后一位赋值给arr[getMax()],删除时顺次移位即可，末位清空，index+1开始

Team teams[] = new Team[0];// 建立队伍对象数组
// 初始化几个角色

public Manager() {//初始化时，可以初始化整个数组若干个元素；
	roles = new Role[] { new Magicer("s1", 1), new Magicer("s2", 2), new Magicer("s3", 3), new Magicer("s4", 4),
			new Soldier("s5", 50), new Soldier("s6", 60), new Soldier("s7", 70) };
}

4.多态的具体运用

4-1在遍历时，可以父类中用this判断包含关系，进行强转父类this，然后输出，【子类也可以重写父类的方法toString，构成多态输出；】
4-2添加时，类型自动转换，
4-3，修改时判断父类包含子类后，建立子类对象，可以给子类的其他属性进行赋值
4-4查找是否包含子类时，先判断输入种类进行非空判断，然后判断
if (animals[i] instanceof Monkey && role.equals(“猴子”)) {

			System.out.println(animals[i].showInfo());
			flag= true;

当修改子类属性时，首先instanceof判断属于关系，然后建立对象强转Magicer m=(Magicer)roles[index]; m.setLevel(input.nextInt（）)最后把修改后的属性重新赋值给数组中元素；roles【index】=m;

5.用抽象类写父类代码质量会更高些，父类如果用抽象，那么不允许建立对象，实例化对象没有意义；
6.修改子类特有属性，先判断是否属于，然后强转，最后把修改后的对象赋值给新建的对象
7.新名词学习，单一性【在继承关系中，子类只能有一个父类】

8.光标变为十字架取消：alt+shift+a

1995年5月23日，Java语言诞生

JDK（Java Development Kit ）：编写Java程序的程序员使用的软件

JRE（Java Runtime Environment）：运行Java程序的用户使用的软件

Server JRE （Java SE Runtime Environment）：服务端使用的 Java 运行环境

SDK（Software Development Kit）：软件开发工具包，在Java中用于描述1998年~2006年之间的JDK

DAO（Data Access Object）：数据访问接口，数据访问，顾名思义就是与数据库打交道

MVC（Model View Controller）：模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用于组织代码用一种业务逻辑和数据显示分离的方法

DK——soft development kit，软件开发工具包。sdk是一个大的概念，比如开发安卓应用，你需要安卓开发工具包，叫 android sdk，比如你开发java程序，需要用到java sdk，所以一般使用sdk这个概念，你需要在前面加上限定词。

JDK——可以理解为 java sdk，它是编写java程序，使用到的工具包，为程序员提供一些已经封装好的 java 类库。

显示菜单方法的两种思想【循环/递归】

一种是循环判断条件为n！=0，另一种是递归思想用到return，到0时结束整个方法，不再次运行菜单

package emploee;

import java.util.Arrays;
import java.util.Scanner;
import java.util.jar.Attributes.Name;

import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;


public class EmploeeMgr {
	public static void main(String[] args) {//主菜单只需要建立对象，调用方法就可以
    EmploeeMgr emploeeMgr=new EmploeeMgr();
    emploeeMgr.menu();
	}

	// 显示菜单功能
	Employee emps[] = new Employee[0];//不用判断非空
	Scanner sc=new Scanner(System.in);
  //因为递归思想运用需要不断返回使用菜单，所以创建对象在外部，否则报错
	public void menu() {
		System.out.println("欢迎光临唐城员工管理系统");
		System.out.println("1.员工入职");
		System.out.println("2.员工查询（列表）");
		System.out.println("3.查询员工");
		System.out.println("4.员工离职");
		System.out.println("0.退出系统");
		
		System.out.println("请选择功能编号");
		int num = sc.nextInt();
		switch (num) {
		//每句话都用个大括号，代表方法块，局部变量名可以一样，也可以和全局变量名一样，值是就近原则
		case 1:
            add();//新建用户；把用户方数组中，数组长度加1最后一位即也新建对象
			break;
		case 2:
			query();//查询所有用户

			break;
		case 3:{
			select();//按条件查询或者模糊查询；
		}

			break;
		case 4:
			 delete();//显示删除前信息；删除；显示删除后信息
		       
			break;
		case 0:
                System.out.println("退出系统，感谢使用");
                System.exit(0);

			return;

		default:
                System.out.println("输入错误，请输入正确的功能编号");
			break;
			
		}//switch 的括号
       menu();//递归方法继续进行；menu方法中包含menu；
	}//menu的括号
	public int getIndex(String sno){
		int index=-1;
		for (int i = 0; i < emps.length; i++) {
			if (sno.equals(emps[i].getSno())) {
				index=i;
			}
		}
		return index;//需要返回in类型所以方法是int；
	}
	public void add(){
		//创建员工对象
		System.out.println("请输入员工工号");
		String sno=sc.next();
		int index=getIndex(sno);
		if (index==-1) {//Duplicate local variable age意思是定义了两个局部变量相同
			System.out.println("请输入员工姓名");
			String name=sc.next();
			System.out.println("请输入员工性别");
			char sex=sc.next().charAt(0);
			System.out.println("请输入员工年龄");
			int age=sc.nextInt();
			System.out.println("请输入员工类型1.班主任2教员3部门经理");
			int type=sc.nextInt();
			//放数组中
			emps=Arrays.copyOf(emps, emps.length+1);
			emps[emps.length-1]=new Employee(name, age, sex, sno, type);
		    System.out.println("添加成功");
		    System.out.println("添加后的员工列表：");
		query();
		}else {
			System.out.println("输入的工号已存在，无法继续添加");
		}
		
	}
	public void query(){
		if (emps.length>0) {
			for (int i = 0; i < emps.length; i++) {
				emps[i].show();
			}
		}else {
			System.out.println("要查询的信息不存在");
		}
	}
	public void select(){
		System.out.println("请输入一个要查询的条件1.姓名，2工号3性别4员工类型5年龄");
	  int choice=sc.nextInt();
	  System.out.println("请输入一个要查询的值");
	  String value=null;
	  int val=0;//必须赋初始值，否则for循环中case报错
	  if (choice==4) {
		val=sc.nextInt();
	}else {
		value=sc.next();
	}
	  for (Employee emp : emps) {//循环遍历时尽量用增强型for
		switch (choice) {
		case 1:
			if (value.equals(emp.getName())) {
				emp.show();
			}
			break;
		case 2:
			if (value.equals(emp.getSno())) {
				emp.show();
			}
			break;
		case 3:
			if (value.charAt(0)==emp.getSex()) {
				emp.show();
			}
			break;
//		case 4:
//			if (val==emp.getAge()) {
//				emp.show();
//			}
//			break;
//		case 5://输出时已经显示男女了
//			if (val==emp.getType()) {
//				emp.show();
//			}
//			break;

		}
	}
	  
	}
	public void delete(){
		//删除前
		System.out.println("当前的员工列表：");
		query();
		//删除操作
		System.out.println("请输入删除员工的工号");
		String sno=sc.next();
		int index=getIndex(sno);
		if (index==-1) {
			System.out.println("要删除的员工不存在，不能被删除");
			menu();
		}else {
			Employee[] temp=new Employee[emps.length-1];//建立临时数组
			System.arraycopy(emps, 0, temp,0, index);
			System.arraycopy(emps,index+1, temp, index,temp.length-index);
			emps=temp;
			System.out.println("删除成功");
		}
		//删除后
		System.out.println("删除后的员工列表：");
		query();
		
	}
}//类名的括号
	


/* public void menu(){  
	   boolean result=true;
	    Employee[] emps=new Employee[0];  
	   while(result){
	   System.out.println("*********欢迎进入唐城员工管理系统************");
	   System.out.println("1.员工入职");
	   System.out.println("2.员工列表");
	   System.out.println("3.员工查询");
	   System.out.println("4.员工离职");
	   System.out.println("0.退出");
	   Scanner sc=new Scanner(System.in);
	   int n=sc.nextInt();
	   switch(n){
	   case 1:break;
	   case 2:break;
	   case 3:break;
	   case 4:break;
	   case 0: result=false;break;
	   default:System.out.println("输入有误，请重新输入!");
	   }
	   }
	   //显示方法一种是循环判断条件为n！=0，另一种是递归思想用到return，到0时结束整个方法，不再次运行菜单
 Employee emp=new Employee(name,sno,age,sex,type2);
		       
		       //2.新的员工对象存放到数组emps中
                emps=Arrays.copyOf(emps, emps.length+1);
               // emps[emps.length-1]=emp;
                emps[emps.length-1]=new Employee(name,sno,age,sex,type2);两句整合成一句，创建对象且调用方法
*/	
/*	case 1:{//创建员工对象；把员工对象放入数组中；
			//1.创建一个员工对象
			System.out.println("请输入员工姓名");
			String nameAdd=sc.next();
			for (int i = 0; i < emps.length; i++) {
				if (nameAdd.equals(emps[i].name)) {
					System.out.println("员工姓名已存在，添加失败");
					menu();//这里不用break，直接返回菜单
				}
			}
			System.out.println("请输入员工年龄");
			int age=sc.nextInt();
			System.out.println("请输入员工性别");
			char sex=sc.next().charAt(0);//必须加.调用方法
			System.out.println("请输入员工工号");
			String sno=sc.next();
			System.out.println("请输入员工类型1.班主任（默认）2.教员3部门经理");
			int type=sc.nextInt();
			int type1=type==3?3:(type==2?2:1);//三元运算嵌套，判断输入编号123符合条件
			//2.新的员工放到数组中
			emps=Arrays.copyOf(emps, emps.length+1);
			emps[emps.length-1]=new Employee(nameAdd, age, sex, sno, type1);//创建重载的过构造方法的对象，直接new就提示了；
		System.out.println("添加成功");
		}
//不用下标查询的方法
			break;*/

new Date()

可以带参，创作时间赋值初始值

new` `Date() ;   ``//参数可以为整数; 也可以为字符串; 但格式必须正确 
new Date("2009-1-1");    //错误 
new` `Date(2009,1,1);    ``//正确 
new` `Date(``"2009/1/1"``);  ``//正确

字符串转化为日期

new SimpleDateFormat("yyyy-MM-dd").parse("20180905")

日期转化为字符串

new SimpleDateFormat("yyyy-MM-dd").format(new Date());

exit(0/1)系统正常/非正常退出

System.exit(0)是将你的整个虚拟机里的内容都停掉了，而dispose()只是关闭这个窗口，但是并没有停止整个application。exit方法把内存都释放了，也就是说连JVM都关闭了，内存里根本不可能还有什么东西
System.exit(0)是正常退出程序，而System.exit(1)或者说非0表示非正常退出程序
System.exit(status)不管status为何值都会退出程序。和return 相比有以下不同点： return是回到上一层，而System.exit(status)是回到最上层

在一个if-else判断中，如果我们程序是按照我们预想的执行，到最后我们需要停止程序，那么我们使用System.exit(0)，而System.exit(1)一般放在catch块中，当捕获到异常，需要停止程序，我们使用System.exit(1)。这个status=1是用来表示这个程序是非正常退出。

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

变量

Java 中主要有如下几种类型的变量
- 局部变量
- 类变量（静态变量）
- 成员变量（非静态变量）全局变量，实例变量
  
  成员变量和类变量的区别
  
  由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。
  
  不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。
  
  成员变量和类变量的区别：
  
  1、两个变量的生命周期不同
  
  成员变量随着对象的创建而存在，随着对象的回收而释放。
  
  静态变量随着类的加载而存在，随着类的消失而消失。
  
  2、调用方式不同
  
  成员变量只能被对象调用。
  
  静态变量可以被对象调用，还可以被类名调用。
  
  3、别名不同
  
  成员变量也称为实例变量。
  
  静态变量也称为类变量。
  
  4、数据存储位置不同
  
  成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
  
  静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。
  
  static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。
  
  特点：
  
  1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
  
  2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
  
  3、静态随着类的加载而加载。而且优先于对象存在。
  
  弊端：
  
  1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
  
  2、静态方法只能访问静态成员，不可以访问非静态成员。
  
  因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
  
  3、静态方法中不能使用this，super关键字。
  
  因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
  
  什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？
  
  成员分两种：
  
  1、成员变量。（数据共享时静态化）
  
  该成员变量的数据是否是所有对象都一样：
  
  如果是，那么该变量需要被静态修饰，因为是共享的数据。
  
  如果不是，那么就说这是对象的特有数据，要存储到对象中。
  
  2、成员函数。（方法中没有调用特有数据时就定义成静态）
  
  如果判断成员函数是否需要被静态修饰呢？
  
  只要参考，该函数内是否访问了对象中的特有数据：
  
  如果有访问特有数据，那方法不能被静态修饰。
  
  如果没有访问过特有数据，那么这个方法需要被静态修饰。
  
  成员变量和静态变量的区别：
  
  1、成员变量所属于对象。所以也称为实例变量。
  
  静态变量所属于类。所以也称为类变量。
  
  2、成员变量存在于堆内存中。
  
  静态变量存在于方法区中。
  
  3、成员变量随着对象创建而存在。随着对象被回收而消失。
  
  静态变量随着类的加载而存在。随着类的消失而消失。
  
  4、成员变量只能被对象所调用。
  
  静态变量可以被对象调用，也可以被类名调用。
  
  所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

数组的缺陷

指定类型；长度固定；增删改查麻烦（用集合框架进行替代）；

/*
 * 	数组的equals
 */
public class TestEquals {
	public static void main(String[] args) {
		int[] nums1 = new int[]{1,2,3};
		int[] nums2 = new int[]{1,2,3};//因为new了对象
		System.out.println(nums1.equals(nums2));//false   调用Object类的equals方法，方法体是nums1==nums2？
		System.out.println(Arrays.equals(nums1, nums2));//true    Arrays类的静态方法，会比较nums1和nums2两个数组的元素
	}
}

日期下单时间

package cn.kgc.tyl.test0918.entity;
import java.util.Date;

import lombok.AllArgsConstructor;

/*
 * 	演示工具方法的调用
 * 
 * 	订单类：	其中下单日期等是日期类型
 *  	其他比如商品类，也有商品的上架日期、生产日期、保质期等都可以调用
 */

public class Order {
	public Order(Date addTime) {
		super();
		this.addTime = addTime;
	}

	private Date addTime;//下单时间


	//其他属性都省略
	
	public void showOrder() {
		System.out.println("下单时间："+Util.formatDate(addTime, "yyyy-MM-dd HH:mm:ss:SSS"));
	}
	
	public static void main(String[] args) {
		Order o  = new Order(new Date());
		o.showOrder();
	}
}

package cn.kgc.tangcco.sample.sample05;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
 * 	静态方法的使用
 * 		静态方法一般是工具方法，被多个类调用
 */
public class Util {
	private Util() {}
	private static SimpleDateFormat sdf;
	/**
	 * 				使用默认格式格式化日期
	 * @param time	时间
	 * @return		字符串
	 */
	public static String formatDate(Date time) {
		sdf = new SimpleDateFormat("yyyy-MM-dd");
		return sdf.format(time);
	}
	/**
	 * 				根据指定格式格式化日期
	 * @param time	时间
	 * @param format格式
	 * @return		字符串
	 */
	public static String formatDate(Date time,String format) {
		sdf = new SimpleDateFormat(format);
		return sdf.format(time);
	}
}

Compareto

返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

如果参数字符串等于此字符串，则返回值 0；
如果此字符串小于字符串参数，则返回一个小于 0 的值；
如果此字符串大于字符串参数，则返回一个大于 0 的值。

javadoc命令生成帮助文档

目的：方便伙伴交接上手工作，给人参考

1.生成ApI：点击左侧File>export导出命令>Javadoc>next>destination>next>finish;

2.查找API：点击类名>右键showin>systemExplore>【在系统文件夹中找到doc包】>点击index-html进行打开；

包按层显示

Eclipse 下的包文件按层显示
```
在package exploer 的右上角 有个向下的标记（在带左右箭头等号的右边），点下——Package presentio,有两个选择：Flat（平行包）和Hierarchical(继承树)
```

初始化信息initial

创建对象：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。

public void initial() {
stuArr[0] = new Student(“学生a”,“2020-03-07”);
stuArr[1] = new Student(“学生b”,“2020-02-07”);
stuArr[2] = new Student(“学生c”,“2020-03-17”);
或者Student stuArr[]={new(),…}
}

方法

方法的返回值只能有一个变属性；或者一句String；不能返回两个值；

使用方法时，防止间接递归，陷入死循环，造成堆栈溢出【比如妻子和丈夫信息；本来是可以调用的，但是本题不可以，本题会形成间接递归，而且无法结束因为妻子类中也调用了丈夫类的showinfo方法，除非妻子类中不要调用丈夫类的showinfo】

多个方法不能嵌套***定义***；可以方法中调用方法；

逻辑代码必须写在方法内部；不能写在类中方法和属性范围以外的地方；

public class Student4 {
	int age = 20;
	if(age < 20) {
	    System.out.println("年龄不符合入学要求！");  
	}
	public String showInfo() {
		return "我是一名学生";
      }
}

隐式构造vs显示构造

【我们自己在类中把构造方法写出来就是显示构造，每个类都有自己的构造方法，默认可以调用自己的无参构造方法，如果重载，自己不写无参构造，就无法在测试类中调用主类的无参构造方法】

java语言为了方便编写也为了安全起见就在每个类实例化中自动加上一个构造方法同时这个构造方法是没有参数的就叫隐式构造方法（当然如果我们写上它就不会再加了）相反我们自己写在类中的构造方法就是显式构造方法，其中的参数可以任意举例为：public class A{ public void show(){ (“隐式构造方法”);} public static void main(String[] args) { A a=new A();//这里就是调用了编辑器默认的构 //造方法即隐式构造方法 (); } } public class A{ public A(){ (“显式构造方法”); } public static void main(String[] args) { A a=new A();//这里就是调用了我们写的构 //造方法即显式构造方法 } }

返回值return

有返回值的需要加输出语句才能打印出来；方法体内部必须要有return；

return后面只能跟一个属性值，如果两个就不能确定是否两个属性一致比如一个int age一个String name;逻辑判断语句只能在方法体内部或方法块，内部类之内，不能方法里定义方法，但是方法体内部可以相互调用方法，如果两个方法不在同一个类中，需要先建立需要调用方法的对象，然后用对象调用；

无返回值的方法内部也可以用return，一般可以省略，输出时不需要输出语句；

值比较和地址比较

【基本数据值比较，对象地址比较】

package cn.kgc.tangcco.sample.sample04;
public class TestStudent5 {
	public static void main(String[] args) {
		Student[] stus = new Student[5];
		Student stu = null;//一个null
		
		for (int i = 0; i < stus.length; i++) {
			stu = new Student();//循环一次，实例化一次
			stu.name = "学生"+i;
			stu.age = (int)(Math.random()*12 +18);
			stus[i] = stu;//5个不同的地址存入数组
		}
		
		for (Student s : stus) {
			System.out.println(s.toString());
		}
	}
}

package cn.kgc.tangcco.sample.sample04;
public class TestStudent4 {
	public static void main(String[] args) {
		Student[] stus = new Student[5];
		Student stu = new Student();//一个地址
		
		for (int i = 0; i < stus.length; i++) {
			stu.name = "学生"+i;
			stu.age = (int)(Math.random()*12 +18);
			stus[i] = stu;//同一个地址五次给数组的元素赋值
		}
		
		for (Student s : stus) {
			System.out.println(s.toString());//bug：5个一样的信息！！！
		}
	}

Arrays是静态方法比较两个数组的元素值

public class TestEquals {
	public static void main(String[] args) {
		int[] nums1 = new int[]{1,2,3};
		int[] nums2 = new int[]{1,2,3};//因为new了对象
		System.out.println(nums1.equals(nums2));//false   调用Object类的equals方法，方法体是nums1==nums2？
		System.out.println(Arrays.equals(nums1, nums2));//true    Arrays类的静态方法，会比较nums1和nums2两个数组的元素

生成银行卡号随机数

银行卡知识点：1.获得卡号的方法；13位随机数+“”将int 转化为字符串；

2.删除银行卡时，如果卡内有余额，友好提醒，目前卡内还有余额，请先取款后再进行操作；

3。如果有登录时，有用户名出现，二级菜单不能单独写，应该把它内嵌在登录的方法里，因为需要用到登录账号的下标

/**
	 *
	 随机卡号方法原型
	 * */
	public String randCardName(){
     
		String str="622262";
		for (int i = 0; i < 13; i++) {
     
			str+=(int )(Math.random()*10)+"";//把int数字转化为字符串
		}
		if (!isExists(str)) {
     
			System.out.println("获得卡号成功"+str);
			
		}else {
     
			System.out.println("获得卡号已重复，将再次获取");
			randCardName();
		}
		return null;
	}
	/**
	 *
	 判断卡号重复方法原型
	 * */
	public boolean isExists(String cardNumber){
     
		boolean flag=false;
		for (int i = 0; i < cards.length; i++) {
     
			if (cards[i]!=null&&cards[i].getCid().equals(cardNumber)) {
     
				flag=true;
			}
		}
		return flag;
	}

Random rd = new Random();
		int cardId = rd.nextInt(99999999);
		for (MarketVipMgr marketVipMgr : vipList) {
     
			if(marketVipMgr.getCardId() == cardId) {
     
				cardId = rd.nextInt(99999999);
			}
		}
		vip.setCardId(cardId);

多个元素

判断密码是否符合规定flag

System.out.print("请输入注册密码：");
		String pwd = "";
		boolean flag = false;
		do {
			pwd = sc.next();
			if(pwd.length()<6) {
				System.out.println("会员密码不能小于6位！请重新输入密码：");
			}else {
				vip.setPwd(pwd);
				flag = true;
			}
		} while (!flag);

String

String是最终类，不可修改长度；如果扩展，会改变原来的地址；当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类，不改变原来的地址。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

SN(序号)	方法描述
1	char charAt(int index) 返回指定索引处的 char 值。
2	int compareTo(Object o) 把这个字符串和另一个对象比较。
3	int compareTo(String anotherString) 按字典顺序比较两个字符串。
4	int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。此方法类似于equalsignoreCase:————————的条件忽略大小写【条件在前】
5	String concat(String str) 将指定字符串连接到此字符串的结尾。
6	boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7	[static String copyValueOf(char] data) 返回指定数组中表示该字符序列的 String。
8	[static String copyValueOf(char] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
9	boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
10	boolean equals(Object anObject) 将此字符串与指定的对象比较。
11	boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
12	[byte] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13	[byte] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14	[void getChars(int srcBegin, int srcEnd, char] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
15	int hashCode() 返回此字符串的哈希码。
16	int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
17	int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18	int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
19	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20	String intern() 返回字符串对象的规范化表示形式。
21	int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
22	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
24	int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25	int length() 返回此字符串的长度。
26	boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
28	boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
29	String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30	String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31	String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32	[String] split(String regex) 根据给定正则表达式的匹配拆分此字符串，返回的是数组。String【】arr=str.split(分隔符);
33	[String] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
34	boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
35	boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36	CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
37	String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
38	String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
39	[char] toCharArray() 将此字符串转换为一个新的字符数组。
40	String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41	String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42	String toString() 返回此对象本身（它已经是一个字符串！）。
43	String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44	String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45	String trim() 返回字符串的副本，忽略前导空白和尾部空白。中间空白不会被忽略；空格也算字符串的长度
46	static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。
47	contains(CharSequence chars) 判断是否包含指定的字符系列。可以进行模糊查询
48	isEmpty() 判断字符串是否为空。

String str1 = “abc”; String str2 = “ab” + “c”; str1==str2是true吗？

**答案：是。**因为String str2 = “ab” + "c"会查找常量池中时候存在内容为"abc"字符串对象，如存在则直接让str2引用该对象，显然String str1 = "abc"的时候，上面说了，会在常量池中创建"abc"对象，所以str1引用该对象，str2也引用该对象，所以str1==str2

String操作以后还需要给新变量赋值才能生效

StringBuffer 可以在自身上操作不产生不可变的String 线程安全效率低

StringBuider可以在自身上操作不产生不可变的String 线程不安全但是效率高

String str1 = “abc”; String str2 = “ab”; String str3 = str2 + “c”; str1==str3是false吗？

**答案：是。**因为String str3 = str2 + "c"涉及到变量（不全是常量）的相加，所以会生成新的对象，其内部实现是先new一个StringBuilder，然后 append(str2),append(“c”);然后让str3引用toString()返回的对象

public static void main(String[] args) {
String str = “abc”;//final char[] value= {‘a’,‘b’,‘c’};
String str2 = str + “def”;//str依然是"abc",不会被改成"abcdef"//对象和字符串相加已经改变了对象
str = str + “def”;//“abc”+"def"后的“abcdef”新字符串，再次给str赋值，覆盖原来的str

	StringBuilder str3 = new StringBuilder("abc");//char[] value= {'a','b','c'};
	str3.append("def");//str3已被修改，{'a','b','c','d','e','f'};
	//根本不用写成str3 = str3.append("def");
	
String str="abc";//创建一个对象

String a="abc";
String b="abc";//创建一个对象

String c="ab"+"cd";//创建三个对象
String str=new String("abc");

    1

jvm会在内部维护的strings pool中放入一个”abc”对象（主动的），并在heap中创建一个String对象，然后将该heap中对象的引用返回给用

StringBuffer 方法

以下是 StringBuffer 类支持的主要方法：

序号	方法描述
1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end) 移除此序列的子字符串中的字符。
4	public insert(int offset, int i) 将 `int` 参数的字符串表示形式插入此序列中。
5	replace(int start, int end, String str) 使用给定 `String` 中的字符替换此序列的子字符串中的字符。

下面的列表里的方法和 String 类的方法类似：

序号	方法描述
1	int capacity() 返回当前容量。
2	char charAt(int index) 返回此序列中指定索引处的 `char` 值。
3	void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 `dst`。
5	int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6	int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7	int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8	int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9	int length() 返回长度（字符数）。
10	void setCharAt(int index, char ch) 将给定索引处的字符设置为 `ch`。
11	void setLength(int newLength) 设置字符序列的长度。
12	CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13	String substring(int start) 返回一个新的 `String`，它包含此字符序列当前所包含的字符子序列。
14	String substring(int start, int end) 返回一个新的 `String`，它包含此序列当前所包含的字符子序列。
15	String toString() 返回此序列中数据的字符串表示形式。

构造方法

(1) 也叫构造器、Constructor，是一个特殊的方法，满足两个特点

① 没有返回值

② 方法名等于类名

(2) 实例化对象时，默认调用的是无参的隐式构造

(3) 可以主动实现某个带参数的构造，用于对象的初始化

(4) 注意

① 默认有一个无参的隐式构造，但是主动实现了一个带参构造，则默认的隐式构造就不提供了

② 没有返回值意味着连void都不能加，一旦加上返回值，成为一个普通的方法（有警告，因为方法跟构造同名）

③ 方法名若不等于类名，那成为一个普通的方法（报错，因为方法没有返回类型）

④ 一般都给一个类提供带参和无参构造，可以通过eclipse快捷键自动生成

Alt+Shift+S -> generate constructor using fields

⑤ 构造中，第一句默认super(),表示调用父类的无参构造

⑥ 一个类的多个构造之间，构成重载。

构造器的重载是方法重载的一种

compare to排序：

compareto只是按类型进行排序，然后结合Arrays.sort(数组名);进行遍历就可以了；

具体调用方法，类实现comparable接口，然后重写 compareto方法；

public class Player implements Comparable<Player> {
     //实现接口
    
    
	@Override
	public int compareTo(Player p) {
     //按照类的属性排序的方法
	
			return this.getAge() -p.getAge();//<0升序，>0降序
		
	}
    
    
}
//在管理类中进行直接用Arrays.sort 方法进行遍历就可以了
[已经在构造方法中初始化数组；或者init方法中初始化]
Arrays.sort(ps);
        for (Student ss:s) {
     
            System.out.println(ss);
        }

类的成员变量、构造函数、成员方法的初始化过程

初始化过程：成员变量->构造函数->成员方法
初始化过程：静态代码块（只执行一次）->构造代码块（每次调用构造方法都执行）->构造方法。执行顺序与代码块所在的具体位置无关。

局部代码块的初始化顺序由具体位置决定。
初始化过程：父类静态代码块->子类静态代码块->父类构造代码块->父类构造方法->子类构造代码块->子类构造方法

 Java对象相关元素的初始化过程

1、类的成员变量、构造函数、成员方法的初始化过程

     当一个类使用new关键字来创建新的对象的时候，比如Person per = new Person();JVM根据Person()寻找匹配的类，然后找到这个类相匹配的构造方法，这里是无参构造，如果程序中没有给出任何构造方法，则JVM默认会给出一个无参构造。当创建一个对象的时候一定对调用该类的构造方法，构造方法就是为了对对象的数据进行初始化。JVM会对给这个对象分配内存空间，也就是对类的成员变量进行分配内存空间，如果类中在定义成员变量就赋值的话，就按初始值进行运算，如果只是声明没有赋初始值的话，JVM会按照规则自动进行初始化赋值。而成员方法是在对象调用这个方法的时候才会从方法区中加载到栈内存中，用完就立即释放内存空间。

初始化过程：成员变量->构造函数->成员方法。
复制代码

package com.yyq;
/**
 * Created by Administrator on 2015-10-30.
 */
class Person {
    int age;
    String name;
    public Person() {
        System.out.println("This is Person()");
        System.out.println("Name:" + this.name + ";  Age:" + this.age);
    }
    public void show() {
        System.out.println("This is show()");
        System.out.println("Name:" + this.name + ";  Age:" + this.age);
    }
}
public class Exercise01 {
    public static void main(String[] args) {
        Person per = new Person();
        per.show();
        per.age = 30;
        per.name = "Wendy";
        per.show();
    }
}

复制代码
输出结果：
This is Person()
Name:null;  Age:0
This is show()
Name:null;Age:0
This is show()
Name:Wendy;Age:30

 

2、类的成员变量、静态代码块、构造代码块、局部代码块、构造方法、成员方法的初始化过程

    静态代码块是在类中方法外成员位置出现，用了static修饰；一般用于给类进行初始化。静态代码块在这个类第一次被调用或实例化的时候就会被执行。 静态代码块只会执行一次，一般会用来初始化一些值，并且在所有对象中全局共享。构造代码块在类中方法外成员位置出现；可以把多个构造方法中共同的代码放到一起，每次调用构造都执行，并且在构造方法前执行，对对象进行初始化。局部代码块在方法中出现，局部位置；限定变量的生命周期，及早释放，提高内存利用率。

初始化过程：静态代码块（只执行一次）->构造代码块（每次调用构造方法都执行）->构造方法。执行顺序与代码块所在的具体位置无关。

局部代码块的初始化顺序由具体位置决定。
复制代码

package com.yyq;
/**
 * Created by on 2015-10-30.
 */
class CodeBlockDemo {
    //静态代码块
    static {
        int a = 1000;
        System.out.println("静态代码块1："+a);
    }
    //构造代码块
    {
        int x = 100;
        System.out.println("构造代码块1："+x);
    }
    //构造方法
    public CodeBlockDemo(){
        System.out.println("Exercise02()");
    }
    //构造方法
    public CodeBlockDemo(int a){
        System.out.println("Exercise02(int a):"+a);
    }
    //构造代码块
    {
        int y = 200;
        System.out.println("构造代码块2："+y);
    }
    //静态代码块
    static {
        int b = 2000;
        System.out.println("静态代码块2："+b);
    }
}
public class Exercise02{
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println("局部代码块1："+x);
        }
        //出错：找不到符号
        //System.out.println(x);
        System.out.println("演示一---------------");
        CodeBlockDemo ex1= new CodeBlockDemo();
        System.out.println("演示二---------------");
        CodeBlockDemo ex2 = new CodeBlockDemo();
        System.out.println("演示三---------------");
        CodeBlockDemo ex3 = new CodeBlockDemo(1);
        {
            int y = 20;
            System.out.println("局部代码块2："+y);
        }
    }
}

复制代码
输出结果：
局部代码块1：10
演示一---------------
静态代码块1：1000     ==>静态代码块只是在该类第一次创建对象的时候才会被调用，而且初始化顺序与代码所在具体位置无关
静态代码块2：2000
构造代码块1：100       ==>构造代码块在每次初始化对象的时候都会被调用，而且初始化顺序与代码所在具体位置无关
构造代码块2：200
Exercise02()
演示二---------------
构造代码块1：100       ==>构造代码块在每次初始化对象的时候都会被调用，而且初始化顺序与代码所在具体位置无关
构造代码块2：200
Exercise02()
演示三---------------
构造代码块1：100        ==>构造代码块在每次初始化对象的时候都会被调用，而且初始化顺序与代码所在具体位置无关
构造代码块2：200
Exercise02(int a):1
局部代码块2：20          ==>局部代码块只是简单的顺序执行程序，与实际位置有关

 

    这里没有将成员变量和成员方法加入分析，但是我们可以知道，静态代码块在类加载的时候就已经初始化了，而成员变量是要在创建对象的时候才会根据构造方法进行分配内存，初始化赋值，所以如果你在静态代码块中打印成员变量或者成员变量赋值的话就会显示出错，显示要将变量类型改为static，而在构造代码块和构造方法中都能正常使用。

初始化过程：静态代码块（只执行一次）->成员变量（每次创建对象都会初始化赋值）->构造代码块（每次调用构造方法都执行）->构造方法（每次创建对象都会调用相匹配的构造方法）->成员方法（对象调用的时候运行）。

 

3、有继承关系的父类和子类的成员变量、构造方法、成员方法的初始化过程

     在创建子类对象的时候会去调用子类的构造方法，其实子类的构造方法的第一条执行语句是super();即会自动去调用父类的无参构造方法，也就是说会自动去检测子类所继承的父类，并对父类的成员变量进行初始化操作。初始化完父类的成员变量、构造方法后，就初始化子类的成员变量和构造方法。因为子类会继承父类的非私有成员变量和成员方法（这里我把成员变量和成员方法都定义为默认访问权限），所以子类中如果定义了相同的成员变量，在初始化的时候就会被覆盖，而成员方法在调用的时候如果父类有子类没有，就执行父类的方法，如果父类没有子类有就执行子类的方法，如果父类有子类也有的话，那子类的成员方法就是复写了父类的成员方法，那最终执行就是子类的成员方法。

初始化过程：父类的成员变量->父类构造方法->子类成员变量->子类构造方法->父类/子类成员方法。

 
复制代码

package com.yyq;
/**
 * Created by Administrator  on 2015-10-30.
 */
class Father{
    int age = 40;
    String name = "Father";
    int num = 321;
    public Father(){
        System.out.println("Father()");
        System.out.println("Name:"+name+"; Age:"+age+"; Num:"+num);
    }
    public void show(){
        System.out.println("I am Father.");
    }
    public void play(){
        System.out.println("Father play.");
    }
};
class Son extends Father{
    int age = 15;
    String name = "Son";
    public Son(){
        System.out.println("Son()");
        System.out.println("Name:"+name+"; Age:"+age+"; Num:"+num);
    }
    public void show(){
        System.out.println("I am Son.");
    }
    public void study(){
        System.out.println("Son play.");
    }
}
public class Exercise03 {
    public static void main(String[] args){
        Son son = new Son();
        son.show();
        son.play();
        son.study();
    }
}

复制代码

 
输出结果：

Father()

Name:Father; Age:40; Num:321

Son()

Name:Son; Age:15; Num:321

I am Son.

Father play.

Son play.

 

4、有继承关系的父类和子类的成员变量、静态代码块、构造代码块、构造方法，成员方法的初始化过程

    因为如果有继承关系的子类和父类，在创建子类对象的时候会自动的去调用父类的构造方法，对父类的数据进行初始化。但是如果父类和子类都有静态代码块的话，那会先执行父类的静态代码块，接着执行子类的静态代码块，因为静态代码块不需要创建对象才能执行，所以在加载类的时候首先运行静态代码块，然后接着运行父类的构造代码块和父类的构造方法，最后才是运行子类的构造代码块和子类的构造方法。

初始化过程：父类静态代码块->子类静态代码块->父类构造代码块->父类构造方法->子类构造代码块->子类构造方法

 
复制代码

package com.yyq;
/**
 * Created by Administrator on 2015-10-30.
 */
class BaseClass{
    static
    {
        System.out.println("静态代码块BaseClass");
    }
    {
        System.out.println("构造代码块BaseClass");
    }
    public BaseClass() {
        System.out.println("构造方法BaseClass");
    }
}
class SonClass extends BaseClass {
    static {
        System.out.println("静态代码块SonClass");
    }
    {
        System.out.println("构造代码块SonClass");
    }
    public SonClass() {
        System.out.println("构造方法SonClass");
    }
}
public class Exercise04 {
    public static void main(String[] args){
        SonClass son1 = new SonClass();
        System.out.println("-------------------");
        SonClass son2 = new SonClass();
    }
}

复制代码

 
输出结果：
静态代码块BaseClass
静态代码块SonClass
构造代码块BaseClass
构造方法BaseClass
构造代码块SonClass
构造方法SonClass
-------------------
构造代码块BaseClass
构造方法BaseClass
构造代码块SonClass
构造方法SonClass

面向对象程序设计

的 3 个主要特征：封装性、继承性、多态性。

方法的形参可以没有；形参才有数据类型；实参没有数据类型，否则相当于再次声明了。调用参数时用的是实参；

封装性（encapsulation）：封装是一种信息隐蔽技术，它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性（对象能接受哪些消息，具有哪些处理能力），而对象的内特性（保存内部状态的私有数据和实现加工能力的算法）对用户是隐蔽的。封装的目的在于把对象的设计者和对象的使用者分开，使用者不必知晓其行为实现的细节，只须用设计者提供的消息来访问该对象。

**继承性：**继承性是子类共享其父类数据和方法的机制。它由类的派生功能体现。一个类直接继承其他类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类有一父类）和多重继承（一个类有多个父类）。类的对象是各自封闭的，如果没继承性机制，则类的对象中的数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。

**多态性：对象根据所接收的消息而做出动作。同一消息被不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，**如是，同一消息即可调用不同的方法。例如：同样是 run 方法，飞鸟调用时是飞，野兽调用时是奔跑。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。在 OOPL 中可通过在派生类中重定义基类函数（定义为重载函数或虚函数）来实现多态性。

Swith修改多个参数的类型

System.out.println("***修改图书****");
			System.out.println("请输入要修改的图书编号");
			String myId=sc.next();
		    int 	index=-1;
		    for (int i = 0; i < books.length; i++) {
				if (myId.equals(books[i].id)) {
					index=i;
				}
			}
		    if (index==-1) {
		    	System.out.println("图书不存在，无法修改");
				menu();
			}else {
				System.out.println("请输入一个要修改的项目a.编号、b.名称、c.作者、d状态");
				String choice=sc.next();
				System.out.println("请输入要修改图书的值");
				String value = null;
				int dvalue = 0;
				if (choice.equals("d")) {
					dvalue = sc.nextInt();
				}else{
					value=sc.next();
				}
					switch (choice) {
					case "a":
						books[index].id=value;
						System.out.println("修改成功");
						break;
					case "b":
						books[index].name=value;
						System.out.println("修改成功");
						break;
					case "c":
						books[index].author=value;
						System.out.println("修改成功");
						break;
					case "d":
                        if (dvalue==1) {
							books[index].state=dvalue;
						}else {
							books[index].state=0;
						}
						
						System.out.println("修改成功");
						break;
					default:
						break;
					}
			}

}

break;

int类型进行三元判断

int type=type3?3:(type2?2:1);//三元运算嵌套，判断输入编号123符合条件，默认为1

类的属性转化为字符串

public class Book {
String id;
String name;
String author;
String price;
String print;//出版社的变量名尽量用press。
int state = 0;// 默认0为未借出，1是已借出//
/**通过技术编号进行赋值1，可以重写toString中进行判断，另外一种是getState方法时返回
public String State(){
String strState = “”;
switch (state) {
case 0:
strState = “未借出”;
break;

	case 1:
		strState = "已借出";
		break;
	}
	return stateStr;
	}
	*/

public Book() {

}

public Book(String id, String name, String author, String price, String print, int state) {

	this.id = id;
	this.name = name;
	this.author = author;
	this.price = price;
	this.print = print;
	this.state = state;
}

public void show() {
	String strState = "";
	switch (state) {
	case 0:
		strState = "未借出";
		break;

	case 1:
		strState = "已借出";
		break;
	}
	System.out.println(id + "\t" + name + "\t" + author + "\t" + price + "\t" + print + "\t" + strState);
}

}

instanceof进行ToString判断

@Override//重载数组的信息；
public String toString() {
	String message="角色名称："+this.getName();
	if (this instanceof Magicer) {//instacnceof后面跟的是子类
		Magicer m=(Magicer)this;
		message+="，魔法等级："+ m.getType()+"，该队员的伤害值："+m.attack();
	}else  if (this instanceof Soldier) {
		Soldier s=(Soldier)this;
		message+="，伤害值："+s.getAttack()+"，该队员的伤害值是："+s.attack();
	}
	return message;
}

封装

回顾：封装

1、为什么需要封装

隐藏实现细节，避免非法赋值

2、主要的封装：属性的封装

属性私有化，提供get和set方法

3.（1）首先属性私有，（2）在set方法中添加控制语句，并在带参构造方法中调用set方法；

private int age;

public int getAge(){//读

return age;

}

public void setAge(int age){//写

if(age>=0&&age<=120){

this.age = age;

}else{

//抛出异常

if(age<0){

age = 0;

}else{

age = 120;

}

}

}

junit的使用方法

1.官网上下载hamcrest-library-2.2架包后，通过右键buildpath，导入到libraries中
2，然后选择junit4导入到libraies
/**
 *junit单元测试工具，方法都必须是没有返回值的类型，
 使用前需要导入import org.junit.Test;包；
 用@Test注释就可以了，方法名不能重名[最多只能有一个，不符合规范]
 * */

loombook的使用方法：

/**
*
*loombok在继承中有参方法不可以使用，父类可以用@Data。@al@no
*子类只能用@data然后用快捷键生成有参构造
*父类改写toString为voidshowInfo.然后子类中调用showifo重写ToString方法【多态】

2)添加注解
a.@Data			
修饰类，表示当前类的所有属性都有get、set方法，当前类有toString、equals等方法
b.@AllArgsConstructor
修饰类，表示当前类有所有属性的带参构造
c.@NoArgsConstructor
修饰类，表示当前类有无参构造
d.@RequiredArgsConstructor
修饰类，表示当前类有部分参数的构造，具体要哪些属性，要@NonNull修饰
e.@NonNull
修饰属性，表示这个属性不允许为空，会出现在带参构造中
f.@Getter、@Setter
修饰属性，表示这个属性有get/set方法

1)导入
1.将loombook包导入到配置文件夹里
2.配置文件夹里面的内容末尾需要加两行代码【架包的版本号也不能省略】
-Xbootclasspath/a:lombok-1.18.0.jar
-javaagent:lombok-1.18.0.jar
3.将架包导入到eclipse的工程里javabuildpath--libraies---addexternaljars,导入lookmbook架包；
4重启eclipse就可以了

类图安装与使用

1下载.三个架包2，放到eclipse中的补丁包里；然后 eclipse重启

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w3q5y9Kw-1601419337264)(Java基础面向对象/image-20200923121100486.png)]

2ctrl+N打开other找到A–uml,找到classDiagram文件，然后选择你要的文件进行拉取。左侧文件移到右侧

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9kSudH7m-1601419337267)(Java基础面向对象/image-20200923131850324.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RAU9sx7g-1601419337268)(Java基础面向对象/image-20200923121538415.png)]

关闭保存后如下图所示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w38q701W-1601419337270)(Java基础面向对象/image-20200923121629357.png)]

[parseInt()]转化为整型

parse：转化为要变为数据类型的方法

abs() 返回参数的绝对值。
rint()返回与参数最接近的整数。返回类型为double。

String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

日期转换

使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。

使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。

使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口

//时间转化为String

public void initial() throws ParseException {// 转化为毫秒时 必须减去1990年，从12月开始，减去一个月；
		workingArr[0] = new Working(1, "技术支持出差", new SimpleDateFormat("yyyy-MM-dd").parse("2020-01-01"), 1);
		workingArr[1] = new Working(2, "主持部门会议", new SimpleDateFormat("yyyy-MM-dd").parse("2020-01-02"), 3);
		workingArr[2] = new Working(3, "做新员工培训", new SimpleDateFormat("yyyy-MM-dd").parse("2020-01-03"), 2);
		workingArr[3] = new Working(4, "做java项目", new SimpleDateFormat("yyyy-MM-dd").parse("2020-01-04"), 1);
	};
	
	
	public String showInfo() {
		return "编号=" + getId() + ", 标题=" + getTitle()  + ", 时间=" + toStr(getCreateDate())
				+ ", 类型=" + getType() + ".";
	}
	public String toStr(Date d) {//日期和时间转换必须要传参；
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");
		return sd.format(new Date());
	}
/*public void addDate(int days) {//多少天后的日期
		Date d = new Date((getYear() - 1900), getMonth()-1, getDay() + days);
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		System.out.println(format.format(d));
	}*/

getset方法

日期要获得当前时间进行封装；设置时属性用String，让后在set方法中进行封装，或者有参构造中国进行封装

private String createDate;//时间
public void setCreateDate(String createDate) {//只有创建笔记时才用newDate方法
		SimpleDateFormat  sf=new SimpleDateFormat("yyyy-hh-dd");
		this.createDate = sf.format(createDate);
	}

	public Student(String name) {
		this.name = name;
		//没有录入时间？要不就修改题目，输入时间，省略不写（改成两个参数的构造，time跟name一样输入）
		
		//也可以用当前时间，转成字符串
		//this.time=(new Date()).toString();//时间格式不太好看
		//改成用SimpleDateFormat的类，就可以将时间格式化为指定的格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		this.time = sdf.format(new Date());//将当前时间格式化成一个指定格式的字符串
	}

   private final int MAX_TEMPERATURE=31;
	private final int MIN_TEMPERATURE=16;
	private String type;//工作模式（制冷、制热、...）
	private int temperature;//设置的温度

public void setType(String type) {//设置工作模式
		if (type.equals("制冷")||type.equals("制热")||type.equals("除湿")) {
			this.type = type;
		}else {
			//this.type = "制冷";//假设默认是制冷，或者干脆保持不变
		}
	public void setTemperature(int temperature) {//设置温度范围
		if (temperature>MAX_TEMPERATURE) {
			this.temperature = MAX_TEMPERATURE;
		}else if (temperature

 
  如果输入要进行判断用三元在set中进行判断或者ifesle 
  	public void setSex(char sex) {
		this.sex = sex=='男'?'男':'女';//默认是男士
	}
 
  this.age = age<0||age>150?18:age;//默认值给18岁； 
  public void setType(int type) {//魔法等级
	if (type>=1&&type<=10) {
		this.type = type;
	}else {
		this.type=1;
	}

}

 
  或者this. type=type3?3:(type2?2:1);//三元运算嵌套，判断输入编号123符合条件判断类型 
  如果int类型要转化为字符串输出，可以在get方法中进行判断publicStringsget(){switch/ifelse};并且toString输出方法要写typesStr; 
  	public String  getType() {//返回类型把int改为String
		String strType="";
		switch (type) {
		case 1:
			strType="班主任";
			break;
		case 2:
			strType="教员";
			break;
		case 3:
			strType="部门经理";
			break;

		
		}
		return strType;
	}
	public void setType(int type) {
		this.type = type==2?2:(type==3?3:1);
	}
 
  使用getset后，有参构造方法也要记得修改 
  public Employee(String name, char sex, int age, String sno, int type) {
	super();//String不能用set();容易报错
	this.name = name;
	setSex(sex);
	setAge(age);
	this.sno = sno;
	setType(type);
}
 
  根据索引查找单条信息 
  //根据索引显示一部电影信息
	public String showMovieByIndex(int index) {
		if(index>=1&&index<=movies.length) {
			return movies[index-1].getInfo();
		}else {
			return "错误";
		}
	}
 
  查询总条数 
  public int queryTotalCount() {
		int count = 0;
		for (int i = 0; i < flowers.length; i++) {
			if (null != flowers[i]) {
				count += 1;
			}
		}
		return count;
	}
 
  分页方法 
  public int queryTotalPages(int totalCount) {//总页数
	return totalCount % PAGE_SAZE == 0 ? totalCount / PAGE_SAZE : totalCount / PAGE_SAZE + 1;
}
 
  查找当前页信息 
  // 显示对应页数的信息
	@Override
	public Flower[] queryFlower(int PageIndex) {
		Flower bea[] = new Flower[3];
		int min = PageIndex * 3 - 3;
		int max = PageIndex * 3;
		if (min > arr.length) {
			return null;
		} else if (max > arr.length) {
			max = arr.length;
		}

		for (int i = min; i < max; i++) {
			if (arr[i] != null) {

				for (int j = 0; j < bea.length; j++) {
					if (bea[j] == null) {
						bea[j] = arr[i];
						break;
					}
				}
			}
		}

		return bean;
	}
 
  获得索引方法 
  public int getIndex(String name){
	int index=-1;
	for (int i = 0; i < goods.length; i++) {
		if (name.equals(goods[i].getName())) {
			index=i;
		}
	}
	return index;
}
 
  获得非空索引的最大下标 
  /**
	 *获得数组非空值的最大下标
	 
	 * */
	public int getMax() {
		int max=0;
		for (int i = 0; i < ps.length; i++) {
			if (ps[i]==null) {
				max=i;
				break;
			}
		}
		return max;
	}
 
  看查找的元素是否在数组中 
  /**
	 * 				在数组中查找一个元素
	 * @param nums	数组
	 * @param find	需要查找的元素
	 * @return		元素的下标 
-1：不存在
	 */
	public int exists2(int[] nums,int find) {
		for (int i = 0; i < nums.length; i++) {
			if (nums[i]==find) {
				return i;
			}
		}
		return -1;
	}
index = exists2(nums, find);
		if (index==-1) {
			System.out.println("不存在");
		}else {
			System.out.println("找到了，下标为"+index);//ok
			nums[i].setage(age);//查找元素并修改
		}
 
  应用：看队员的随机技能，冒泡排序，查找某类型的球员 
  	/**
	 *获得数组非空值的最大下标
	 
	 * */
	public int getMax() {
		int max=0;
		for (int i = 0; i < ps.length; i++) {
			if (ps[i]==null) {
				max=i;
				break;
			}
		}
		return max;
	}
 
  public  void  sortByAge() {//
    int max=getMax();
	Player[] temp=Arrays.copyOf(ps, max);//复制的时原数组非空值的最大下标，不是数组长度；否则报空指针异常；
	Arrays.sort(temp);
   if (temp.length>0) {
	
	for (Player p : temp) {
		System.out.println(p.toString());
	}
}
	
}
	/**
	 *3.随机观看球员技能展示
	 
	 * */
public  void showSkill()  {
	 int max=getMax();
	System.out.println(max);//获取最大下标
	int index=(int)(Math.random()*max);//此处不可以乘以数组的长度，否则报空指针异常；
	System.out.println(ps[index].getName()+"展示了他的特殊技能"+ps[index].getSkill());
}


	/**
	 *4.根据职业类型查找球员
	 
	 * */
public  void   selectByRole(String role) {
	Boolean flag=false;
	int max=getMax();
	for (int i = 0; i < max; i++) {//在最大下标范围内查找球员；
		if (role.equals(ps[i].getRole())&&ps[i].getRole()!=null) {
		
			flag=true;
			System.out.println(ps[i].toString());
		}
	}
	
	if (!flag) {
		System.out.println("目前没有找到"+role+"职业的人");
	}
	
}

 
  查看所有 
  	public void print() {
		for (int i = 0; i < devices.length; i++) {
			if (devices[i]!=null) {//非空判断后直接输出
				devices[i].showInfo();
				System.out.println();
			}else {
				break;
			}
		}
	}
 
  case 2:{
		System.out.println("***图书列表****");
		System.out.println("图书编号"+"\t"+"图书名称"+"\t"+"作者"+"\t"+"价格"+"\t"+"出版社"+"\t"+"状态");
			
		if (books.length >0) {
			for (Book book : books) {
				book.show();
			}
		}else {
			System.out.println("未查询到图书，查询失败");
		}
	}
		
		break;
 
  查看某种 
    public void selectgoods(){
    	Scanner sc=new Scanner (System.in);
    	boolean flag = false;
		System.out.print("请输入查找的商品类别：");
		String type = sc.next();
		for(int i=0; i
 
  添加 
  	//添加东西
	public int tianDevice(Device device) {
		
		for (int i = 0; i < devices.length; i++) {
			if (devices[i]==null) {
				devices[i]=device;
				return 1;
			}
		}
		return 0;
	}
 
  public void addgoods(){//添加商品
    	Scanner sc=new Scanner (System.in);
    	System.out.println("请输入商品名称");
    	String name=sc.next();
    	int index=getIndex(name);
    	if (index!=-1) {
			System.out.println("商品已存在，添加失败");
			return;
		}	
    	System.out.println("请输入商品类别");
    	String type=sc.next();
    	System.out.println("请输入商品品牌");
    	String brand=sc.next();
    	System.out.println("请输入商品价格");
    	double price=sc.nextDouble();
    	System.out.println("请输入商品数量");
    	int stock=sc.nextInt();
    	Goods good =new Goods();
    	good.setName(name);
    	good.setBrand(brand);
    	good.setType(type);
    	good.setPrice(price);
    	good.setStock(stock);
    	goods=Arrays.copyOf(goods, goods.length+1);
    	goods[goods.length-1]=good;
    	System.out.println("添加成功");
    	querygoods();
    }
 
    public void addtocar(){
    	querygoods();
    	Scanner sc=new Scanner (System.in);
    	System.out.println("请输入商品名称");
    	String name=sc.next();
    	int index=getIndex(name);
    	if (index==-1) {
			System.out.println("商品不存在，添加失败");
			return;
		}	
    	
    	System.out.println("请输入购买数量");
    	int count=sc.nextInt();
    	
    	/**z**/Shopcar shopcar=new Shopcar();
    	shopcar.setName(name);
    	shopcar.setType(goods[index].getType());
		shopcar.setBrand(goods[index].getBrand());
		shopcar.setPrice(goods[index].getPrice());
		shopcar.setCount(count);//购物车的数量
			 
	if (count< goods[index].getStock()) {//？？此时应该如果购买数量大于库存进行return；
		System.out.println("输入数据不合法，购买失败");
		return;
	}
    	shopcars=Arrays.copyOf(shopcars, shopcars.length+1);
    	shopcars[shopcars.length-1]=shopcar;
    	System.out.println("添加成功");
    	goods[index].setStock(goods[index].getStock()-count);//添加成功后记得减去库存
    }
 
  删除 
  public int shanDevice(int id) {
		if (devices[0]==null) {
			return 0;
		}
		for (int i = 0; i < devices.length; i++) {
			if (devices[i]!=null) {//不为空时，才把末位清空；
				for (int j = id-1; j < devices.length-1; j++) {
					devices[j]=devices[j+1];					
				}
				devices[devices.length-1]=null;
				return 1;
			}
		}
		return 0;
	}
}
 
  	case 4:{
		System.out.println("***删除图书****");
		System.out.println("请输入要删除的图书编号");
		String delId=sc.next();
		int index=-1;
		for (int i = 0; i < books.length; i++) {
			if (delId.equals(books[i].id)) {
				index=i;
			}
		}
		if (index==-1) {
			System.out.println("您要删除的图书不存在，删除失败");
			menu();
		}else {
			Book[]temp=new Book [books.length-1];//数组长度假设删除后为temp
			System.arraycopy(books, 0, temp, 0, index);
		//System.arraycopy(books, index+1, temp, index, books.length-1-index);//两种长度都可以；
			System.arraycopy(books, index+1, temp, index, temp.length-index);
			books=temp;//删除后的数组赋值给原数组名称；
			System.out.println("删除成功");
		}
	}
		
		break;
 
    public void deletegoods(){
    	querygoods();
    	Scanner sc=new Scanner (System.in);
       	System.out.println("请输入商品名称");
    	String name=sc.next();
    	int index=getIndex(name);
    	if (index==-1) {
			System.out.println("商品不存在，删除失li败");
			return;
		}	
    //商品存在就建立对象，
    	Goods  good=new Goods();
    	Goods temp[]=new Goods[goods.length-1];
    	System.arraycopy(goods,0,temp, 0, index);
    	System.arraycopy(goods,index+1,temp, index,temp.length-index);
    	goods=temp;
    	System.out.println("商品删除成功");
    	querygoods();
    	   }
 
  报废 
  修改 
  public void modifygoods(){
    	Scanner sc=new Scanner (System.in);
    	querygoods();
       	System.out.println("请输入商品名称");
    	String name=sc.next();
    	int index=getIndex(name);
    	if (index==-1) {
			System.out.println("商品不存在，删除失败");
			return;
		}	
       System.out.println("请输入要修改商品的库存");
       int stock=sc.nextInt();
       goods[index].setStock(stock);//12，13行可以简化为一行；
       System.out.println("修改商品库存成功");
       querygoods();
    }
 
  
 
  查找是否存在 
  获得随机数 
  Random rand = new Random();
 jia = rand.nextInt(6)+1;//1-6的随机数，括号里是数字的范围种子 
  归还东西【根据编号查找】 
  	public boolean zuDevice(int id ,String number) {
		if (id<0||id>devices.length) {
			return false;
		}
		for (int i = 0; i < devices.length; i++) {
			if (devices[i]!=null&&id==devices[i].getId()) {
				devices[i].setResidue(devices[i].getResidue()-1);				
				for (int j = 0; j < rentDevices.length; j++) {
					if (rentDevices[j]==null) {//租的数组为空就添加
						rentDevices[j].setNumber(number);//如果租用数组等于空  学号就等于输入的
						
					}
				}
				return true;
			}
		}

		
		return false;
	}
 
  退出 
    public void exit(){
    	Scanner sc=new Scanner (System.in);
    	System.out.println("输入0退出，输入其他任意键继续进行");
    	String str=sc.next();
    	if (str.equals("0")) {
			System.out.println("感谢使用，退出程序");
			System.exit(0);//相当于return；
		}else {
			System.out.println("取消退出，程序继续运行");
			menu();
		}
		}
 
  重载 
  (1) 定义：Overloading，同一个类中的多个方法，方法名一样，依靠参数互相区分 
  package tes0915;
/*
 * 重载
 * 	若有多个类型兼容的方法，实际调用一个类型更加接近的方法
 */
public class TestOverloading2 {
	public void test(int f) {}
	public void test(float f) {}
	public void test(float[] f) {}
	
	public static void main(String[] args) {
		TestOverloading2 t = new TestOverloading2();
		short num1 = 5;
		t.test(num1);//调用第一个test (short跟int的类型更加接近)
		
		long num2 = 5;//小可以自动转化为大 
		t.test(num2);//调用第二个test(long不可以自动转成int，不能调用第一个)
		
		int[] nums3 = {1};//编译报错范围不一致
		//t.test(nums3);//报错（int[]不可以自动类型转换成float[]，自动类型转换只能是7种值类型之间）
	//类型TestOverloading2中的方法测试（int）不适用于参数（int[]）
	}
}
 
  package tes0915;



import java.util.Arrays;

/*
 * 	
 * 	下面代码涉及到如下三个方法
		 * 	println(String str)
		 * 	println(Object obj)
		 * 	println(char[] arr)
 *  
 */
public class TestOverloading3 {
	public static void main(String[] args) {
		int[] nums1 = {1,2,3};
		char[] nums2 = {97,98,99};
		//浠ヤ笅鍥涗釜璋冪敤鐨勯兘鏄痯rintln(String str)鏂规硶
		System.out.println("nums1="+Arrays.toString(nums1));//nums1=[1, 2, 3]
		System.out.println("nums1="+nums1);//地址
		System.out.println("nums2="+Arrays.toString(nums2));//nums2=[a, b, c]
		System.out.println("nums2="+nums2);//地址？？？？
		
		System.out.println(nums1);//[I@15db9742调用的是println(Object obj)方法（int[]可以自动向上转型成Object类型）
		System.out.println(nums2);//abc调用的是println(char[] arr)方法
	}
}

 
  /*
 * 重载
 * 	若有多个类型兼容的方法，实际调用一个类型更加接近的方法
 */
public class TestOverloading2 {
	public void test(int f) {}
	public void test(float f) {}
	public void test(float[] f) {}
	
	public static void main(String[] args) {
		TestOverloading2 t = new TestOverloading2();
		short num1 = 5;
		t.test(num1);//调用第一个test (short跟int的类型更加接近)
		
		long num2 = 5;
		t.test(num2);//调用第二个test(long不可以自动转成int，不能调用第一个)
		
		int[] nums3 = {1};
		t.test(nums3);//报错（int[]不可以自动类型转换成float[]，自动类型转换只能是7种值类型之间）
	}
}
 
  (2) 比如 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FSze1W1s-1601419337272)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/wps1.jpg)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bfa6OX2X-1601419337273)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/wps2.jpg)] 
  (3) 好处：多个功能相似的方法，用用一个方法名 
  (4) 注意 
  ① 重载仅仅跟方法名和参数列表（参数类型，个数，顺序）有关，跟其他无关 
  ② 参数是指参数的类型或者个数，跟参数名无关 
  ③ 实际调用重载的方法时，根据形参调用一个跟实参类型一致的方法 
  若没有一致的方法，找一个类型兼容的方法 
  若多个类型兼容的方法，找一个类型更加接近的方法 
  若没有类型兼容的方法，报错！ 
  继承 
  如果子类没有特殊的属性，无法建立有参构造 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oTJxB32F-1601419337274)(Java基础面向对象/image-20200923115134917.png)] 
  提示没有属性进行初始化； 
  loombok在继承中无参构造，不可使用，因为没法调用父类的公共属性； 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PlyNtZMs-1601419337276)(Java基础面向对象/image-20200923113837232.png)] 
  如果子类没有特殊的属性，子类就没有有参构造，但是无参构造有两个，可以直接调用父类的两个构造方法。上图都是子类的无参构造； 
  package cn.kgc.tyl.test0923.entity;

import lombok.NoArgsConstructor;

/**
 *1.使用封装分别创建实体类Dog和1.使用封装分别创建实体类Dog和Penguin,其中:
 Dog类中
   包含属性(name,love,health,strain) 
   方法:print()显示狗狗的信息
   构造方法:无参构造函数和带参构造函数,其中:
 Dog类中
   包含属性(name,love,health,strain) 
   方法:print()显示狗狗的信息
   构造方法:无参构造函数和带参构造函数
 Penguin类中
    包含属性(name,love,health,sex)  sex定义为静态常量并且赋值为Q仔
    方法:print()显示企鹅的信息
   构造方法:无参构造函数和带参构造函数
 
 * */
@NoArgsConstructor

public class Dog {
	//包含属性(name,love,health,strain
	private String name,Strain;
	private int love,health;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getStrain() {
		return Strain;
	}
	public void setStrain(String strain) {
		Strain = strain;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		if (love>100||love<0) {
			this.love = 0;
		}else {
		this.love = love;
	}
		}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		if (health>100||health<0) {
			this.health = 0;
		}else {
		this.health = health;
	}
	}
	public Dog(String name, String strain, int love, int health) {
		super();
		this.name = name;
		Strain = strain;
		setHealth(health);
		setLove(love);
	}
	@Override
	
	public String toString() {
		return "狗狗的名字=" +this.getName()+ ", 品种=" + this.getStrain()+ ", 和主人的亲密的=" + this.getLove() + ", 健康值是=" + this.getHealth() + "]";
	}
	public void print() {
		System.out.println("狗狗的名字=" +this.getName()+ ", 品种=" + this.getStrain() + ", 和主人的亲密的=" + this.getLove() + ", 健康值是=" + this.getHealth() + "."
		); 
	}	

}
*************************************************************************
@NoArgsConstructor
public class Penguin {
	// 包含属性(name,love,health,sex
		private String name;
		private int love,health;
		public static final String SEX="Q仔";
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		
		public int getLove() {
			return love;
		}
		public void setLove(int love) {
			if (love>100||love<0) {
				this.love = 0;
			}else {
			this.love = love;
		}
			}
		public int getHealth() {
			return health;
		}
		public void setHealth(int health) {
			if (health>100||health<0) {
				this.health = 0;
			}else {
			this.health = health;
		}
		}
		
		public Penguin(String name, int love, int health) {
			super();
			this.name = name;
			setHealth(health);
			setLove(love);
		}
		@Override
		public String toString() {
			return "企鹅的名字=" +this.getName()+ ", 性别=" + this.SEX + ", 和主人的亲密的=" + this.getLove() + ", 健康值是=" + this.getHealth() + "]";
		}
		public void print() {
			System.out.println("企鹅的名字=" +this.getName()+ ", 性别=" + this.SEX + ", 和主人的亲密的=" + this.getLove() + ", 健康值是=" + this.getHealth() + "."
			); 
			}
			**********************************************************************
public class Test {
  public static void main(String[] args) {
	
	
	//狗类
	Dog dog2=new Dog("小黑", "牧羊犬", -11, 0);
	dog2.print();
	Dog dog1=new Dog();
	dog1.setName("小白");
	dog1.setHealth(19);
	dog1.setStrain("藏獒");
	dog1.setLove(-11);
	dog1.print();
	//企鹅类
	Penguin p1=new Penguin();
	p1.setLove(100);
	p1.setName("小白");
	p1.setHealth(90);
	p1.print();
	Penguin p2=new Penguin("小花", -100, 105);
	p2.print();
	
}
}

运行结果
狗狗的名字=小黑, 品种=牧羊犬, 和主人的亲密的=0, 健康值是=0.
狗狗的名字=小白, 品种=藏獒, 和主人的亲密的=0, 健康值是=19.
企鹅的名字=小白, 性别=Q仔, 和主人的亲密的=100, 健康值是=90.
企鹅的名字=小花, 性别=Q仔, 和主人的亲密的=0, 健康值是=0.

0923笔记
初始化就是赋值的意思；
用构造函数来创建对象【包括有参和无参构造】
也可以在用构造函数创建对象的同时进行给对象赋值（实例化）
封装就是属性私有化，然后提供对外的接口（方法）【建立公共的setget方法】，供外部访问和调用，
final是最终的意思用在性别，数据库的密码，一周天数等固定值，修饰属性时是常量，调用属性不能再次赋值，否则报错，final的用法保证了程序的健壮性；
 
  this 
  (1) 含义 
  当前类被实例化之后的对象，注意不是类，是对象 
  (2) 作用 
  ① this.属性 
  在一个类中，局部变量可以与成员变量同名，但是局部变量优先,如果非要访问成员变量的属性，则必须使用 this.color 
  this 代表当前这个对象，也就是当前谁调用这个方法则这个对象就是 
  局部变量和属性同名的问题：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ofADudv0-1601419337277)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/wps3.jpg)] 
  还可以区分当前类和父类的属性同名问题 
  若没有同名，this可以省略不写；同名的话必须加this 
  ② this.方法(实参) 
  一般都省略不写：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J2MpUSqv-1601419337278)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/wps4.jpg)] 
  除非当前类的父类也有一个同名的方法，用this强调是当前类的方法，不是父类的同名方法。 
  ③ this(实参) 
  一个构造中，调用当前类的另一个构造： 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H7f1XpBl-1601419337280)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/wps5.jpg)] 
  再比如： 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GUFtfMYg-1601419337281)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/wps6.jpg)] 
  注意：必须出现在构造的第一句 
  成员变量和局部变量 
  定义的作用域【整个类中vs方法体内部】；初始值赋值【有默认初始值vs必须声明时赋值】；使用优先级【就近原则】；访问修饰符【局部变量不能final，和权限修饰符修饰】；生命周期【方法体内部，对象】 
  成员变量和局部变量 
  (1) 成员变量 
  属性、字段、Field 
  有默认的初值 
  (2) 局部变量【使用前需要赋初始值；在方法块代码块内或者作为形参；作用域】 
  形参、方法体中的局部变量、代码块中的局部变量… 
  必须初始化，否则不能使用 
  注意：若成员变量和局部变量同名，可以通过this区分，否则局部变量的优先级高 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eH3FMUuD-1601419337282)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200915155726980.png)] 
  面向对象 
  (1) 对象数组中的每个元素都是对象，保存的都是个地址 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L7pmCexM-1601419337283)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200915153922302.png)] 
   
    形参（定义方法时的形式参数）实参（调用时使用的参数）
  
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mwNKXRlh-1601419337284)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200915154859919.png)]
  
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KfkOtmXT-1601419337285)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200915151355498.png)]
  
   
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pfIih2i2-1601419337286)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200915154049600.png)] 
  参数类型相当与一个一个占位符，调用时直接调用变量就行 
  参数列表与参数个数；顺序和参数类型； 
   
    递归要有边界，否则死循环；实际上不断调用自己
  
    Java内存.数组本身就是对象，存储在堆中
 变量引用名在栈区，指向真正的堆中的具体对象【建模的概念】
 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TmGQwyc1-1601419337287)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912095326933.png)]
 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HWFwdZUE-1601419337288)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912085722660.png)]
  
   
  4.静态方法传值【j结果输出为1，1】 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7AJolU7E-1601419337289)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912092559460.png)] 
  对象指向可以改变属性，数值不行【输出为null,】唐元 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mxMKiLUl-1601419337291)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912093029981.png)] 
   
    面向对象的本质就是以类的方式组织代码，以对象组织（封装）数据；
  
    new的本质就是在调用类的无参构造，通过new方法对对象实例化[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7xRCIDT1-1601419337292)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912094238138.png)]
  
   
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u4cPYys4-1601419337293)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912094502599.png)] 
  封装[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TpEOcwBJ-1601419337293)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912103215638.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hkZ68mOL-1601419337294)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912103404822.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oB6B0R1u-1601419337295)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912103924577.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CEMFpdPp-1601419337297)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912104027282.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjfmBGcb-1601419337298)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912104203643.png)] 
  调用方法时//当前类//继承父类的 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-92dL1CrC-1601419337298)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912105028007.png)] 
  1继承时，父类不是私有才能调用否则报错） 
  不能继承final类 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vTi6xKGG-1601419337299)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912105207221.png)] 
  this（），super ()方法都应该放在第一行，默认调用父类，super（），互斥的 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5tWZGILC-1601419337299)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912105617270.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cPD8egns-1601419337301)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912105739141.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-puhg0DaB-1601419337301)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912110517954.png)] 
  多态【动态编译：可扩展性】 
  方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。 
   
    (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
  
    (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
  
    (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
  
    多态的优点 
     
     \1. 消除类型之间的耦合关系 
     \2. 可替换性 
     \3. 可扩充性 
     \4. 接口性 
     \5. 灵活性 
     \6. 简化性 
    
 多态存在的三个必要条件 
     
     继承 
     重写 
     父类引用指向子类对象 
    
 比如：
 Parent p = new Child();
 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
 多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
 多态引用时，构造子类对象时的构造方法的调用顺序
 1，先调用超类的构造方法，多重超类首先调用最远超类的方法；
 2，然后再执行当前子类的构造方法；
 调用时需要谨慎处理调用方法
 对于多态，可以总结以下几点：
 一、使用父类类型的引用指向子类的对象；
 二、该引用只能调用父类中定义的方法和变量；
 三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）;
 四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错
  
   
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gockScwe-1601419337302)(Java基础面向对象/image-20200924222924165.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gL1wknKQ-1601419337303)(Java基础面向对象/image-20200923165309764.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tQYvu7v7-1601419337304)(Java基础面向对象/image-20200923165610851.png)] 
  向上转换，自动转换，父类的引用指向子类，；实现的时父类的方法【如果出现重写，可以走子类的同名同参方法；】
 向下转换，强制 转换，使用前必须先进行判断子类是否属于父类，实现子类的私有方法 
  多态：多种形态
在继承情况下，首先，子类将父类方法重写。然后，实例化子类的对象，给父类的引用赋值。结果，调用方法会自动调用子类重写后的方法。
3、重写和多态
(1)子类重写父类的方法后，将父类的方法覆盖了
只要测试类实例化的是子类对象，调用的肯定是子类重写的方法
(2)子类特有的方法，用父类的引用是无法调用的
A a = new B();//假设B是A的子类
a.只能调用父类有的方法()
可能1：子类重写了，多态
可能2：子类没有重写，调用父类的方法
a.不能调用子类特有的方法，除非类型转换
if(a instanceof B){
((B)a).调用子类特有的方法
}
 
  alt+enter 自动补全 
  psvm主方法入口； 
  4.for循环 
  方法调用时 
   
     实参跟形参类型兼容就可以
  
     byte\short\char		->	int		->	long	->	float		->	double
  
     【double 不能转化为float，long可以】
  
   
  重写 
  重写:子类继承父类以后,可以对父类中的同名同参数的参数的方法进行覆盖 
  javaBean的要求：规范的java类 
  1、公开的类 
  2、所有的属性都是私有的，并提供公开的get和set封装 
  3、提供无参构造 
  (1) 默认就有无参构造 
  (2) 但是，若主动实现了带参构造，则没有默认的隐式构造了 
  1、重写的规则 
  (1) 重写：继承的前提下，子类将父类的同名同参方法，重新实现 
  (2) 多态：在重写的前提下，若将父类的引用，指向子类的对象，则调用方法的结果是多态的 
  (3) 重写也要符合一定的规则【了解即可，一般重写直接跟父类的方法原型一样】 
  ① 权限修饰符不能严于父类（可以一样，可以更大，比如protected可以变成public） 
  ② 返回类型可以跟父类一致，或者返回的是父类返回值的子类（比如父类返回Object，子类可以返回Person） 
  ③ 不可以比父类抛出更多的异常（可以更少或者更小，甚至没有） 
  ④ static的静态方法，没有重写的说法 
  2、多态的理解：Object类的常用方法重写 
  (1) toString方法 
  ① 默认情况下，Object类的toString方法会返回一个“类名@地址” 
  ② Date类，重写的toString方法会返回一个”Fri Apr 24 16:53:39 CST 2020”格式 
  ③ String类，重写的toString方法会返回”字符串本身” 
  ④ 自己封装的Xxx类，可以重写toString方法，返回指定格式的”属性=值” 
   
    手工重写
  
    @Data注解、@ToString注解
  
    eclipse快键键
  
   
  (2) clone方法 
  (3) equals方法 
  ① 默认情况下，Object类的equals方法，直接用==比较两个对象的地址 
  ② String类，重写了equals方法，比较两个字符串的每个字符是否一样 
  ③ Date类，重写了equals方法，比较两个日期的转成毫秒后是否一样 
  ④ 自己封装的Xxx类，可以重写equals方法，比较感兴趣的属性 
   
    手工重写
  
    @Data注解、@EqualsAndHashCode注解
  
    eclipse快键键
  
   
  Instanceof大包含小（ 大 《属于————小） 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HIxvRquh-1601419337305)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912115501671.png)] 
  static静态 
  类变量是全局变量，实例化不能在局部定义，比如，在方法里进行实例化会报错； 
  	private int no;
	
	public static int currentNo;//当前编号(多个Student对象，共用一个)
	
	public Student(){
		this.no = ++currentNo;//实现编号自增
	}
 
  ![ 
  ](Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200916151643710.png) 
  执行顺序：静态代码块（用来赋初始值）》匿名代码块》构造方法 
  静态代码块只执行一次（存储初始化数据），普通方法对象调用一次执行一次[ 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iUAkV84g-1601419337305)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912121533104.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jfcCWSvt-1601419337307)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912121927773.png)] 
  类 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lPN3SvhO-1601419337308)(Java基础面向对象/image-20200924221926872.png)] 
  1、面向对象编程OOP
(1)由来：分类
(2)如何分类：根据特征
(3)一类事物具备相似的属性、共有的方法
比如：电商系统中的各种订单，都具备共同的属性和方法：
属性：下单时间、下单人、总价、商品编号、购买数量、收货人、订单状态。。。
方法：结算订单、支付、评价。。。

2、类和对象
(1)一类事物，包括多个，比如订单，有很多个订单，这些叫对象
(2)一类事物抽象出来的，叫类，比如订单类
(3)类是由对象抽象而成的，对象则是类具体化的
比如字符串类String是类，但是str1,str2...则是String类的对象

3、设计和使用类
(1)设计类
①设计类的属性
②设计类的方法
③[不常用]设计类的其他成员
1)构造
2)内部类\内部接口
3)代码块
(2)使用类
①类实例化，得到对象
②对象.属性和对象.方法()调用属性和方法
类可以作为一种数据类型存在
  对象的数据类型就是类**静态特征====属性****动态特征====方法**
类是从n个对象抽象出来的；一个类有多个对象；一个对象属于一个类

**为什么有些变量时全局变量,有些是局部变量呢?**

  =作用域是由变量的声明位置决定的；根据作用域决定全局变量还是局部变量

记得加注释【方法和类上/*；属性后面加//】
1.属性：主体数据
2.方法：
对象的类型是类；
类的规范首字母大写，属性名规范第一个字母小写，后面单词首字母大写；
1-1new Student();//创建对象，其实是new 类的构造方法；左边如果没有名字，那么就是匿名对象；Student s1=new Student();
1-2//给对象赋值，s1.stuName=”丽丽”;//对象对学生类属性的引用并给对象赋值；
1-3访问使用对象的值，或调用方法 syso(s1.stuName);
          s1.study();

2  TestStu类中要记得导entity包中的主类Student的包；用ctrl+shift+o或者Alt+/；
分包原因是因为单一职能原则；归于同一属性；
一 对象
用来描述客观事物的一个实体,由一组属性和方法构成
二 属性
对象具有各种特征,每个对象的每个属性都有特定值
三 方法
对象的执行操作
四 类 
具有相同属性和方法的一组对象的集合,类是对象的抽象,对象是类的具体,类是抽象的概念,仅仅是模板.
对象是一个你能看的见摸得着的具体实体.
五 面向对象oop
所有java程序都以类class为组织单元
关键字class定义自定义的数据类型

1类--{属性，方法，构造方法，代码块，内部类接口}，抽象类，接口--------对象；
2方法，构造方法（形参实参，返回类型，this，super），抽象方法，静态方法；
3.变量 局部，成员（封装过程中，在getset和构造方法中this.不可省略，否则在方法块中，同名变量名根据就近原则，指向的都是局部变量，形参，在toString方法中可以省略，因为此时没有同名变量，就是指的类变量）
4.关键字（this/super/extends/implements/static/final/abstract）与访问修饰符（private/friendly-default/protected/public）
5。OOP-封装（隐藏细节）-继承（可重用性）-多态（动态绑定，两种转换）
 
  抽象类 
  抽象类总结规定 
   
   \1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。 
   \2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。 
   \3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。 
   \4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。 
   \5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。 
   
  0924笔记
 *，1在版本控制【版本迭代】过程中.如果改写Java文件复制后，要检查是否导错包 
   
   2.重写是不同类中，存在继承关系，同名同参，子类的访问权限》=父类；子类的返回值类型《=父类； 
   3.代码设计优化过程中，因为继承的关系，父类中的一些方法没有必要实例化，所以方法体可以省略，然后引出抽象的概念把方法改为抽象方法，让子类重写实现带有自己特点的同名方法，叫重写； 
   4.抽象类用abstract关键字标注，子类必须实现父类的抽象方法，所以抽象针对的是父类，并且父类一定不是private类型的【否则不能被子类访问】 
   5.抽象类有构造方法是一个不完全的类，但是不能被实例化，不能够通过类名进行创建对象； 
   6.抽象类中可以有普通方法，也可以有抽象方法【抽象方法用abstract修饰方法，没有花括号的方法体，参数列表的括号后加分号结束】一个抽象类可以没有抽象方法，但是有抽象方法的类一定是抽象类； 
   7.extends关键字，必须符合isa的关系，子类不能继承父类的构造函数，但是可以调用；子类可以继承父类的私有属性，但是不能被访问；子类不能继承父类中的构造函数，只能有super()来调用父类的构造函数；子类默认调用父类的无参构造； 
   8.写代码过程中有类似的代码，为了解决代码冗余的问题，引入了抽象类，抽象类中可以有抽象方法和实力方法；子类要么必须实现父类的抽象方法，要么子类也是抽象方法；
 add implements methods:子类必须实现父类所有的抽象方法、
 make type [Dog子 类] abstract: 将子类也变为抽象类；
 当子类也变为抽象类的缺陷：子类也无法建立对象，实例化了。一个类可以是子类也可以是父类；
 9final关键字修饰类名，方法名属性名；修饰类名，最终类，不能被继承；
 修饰变量，属性变为常量，属性名应该【不是】必须大写，此时常量必须赋初始值，并且运行过程中不能二次赋值；
 修饰方法，不能和abstract【抽象需要被继承】同时使用，方法不能被重写【重写发成在多个类有继承关系中】 ，方法体必须有【否则为抽象方法，然后变成抽象类】 
   
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E7Z1Wamt-1601419337309)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912122556990.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MXfahKQs-1601419337310)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912122643106.png)] 
  接口 
   
   *test0928笔记
 1.接口是一种能力，包含方法，实现了一种方法，就具有了一种能力；
 2.接口中的属性都是静态最终的常量，方法都是抽象的具体的【可以称为抽象方法，因为具有抽象方法的类是抽象类，已经声明为接口了】
 3.接口不能实例化，也没有构造 方法；
 4.接口可以多实现，体现了灵活性，如果有多个接口，用逗号隔开，
 5.子类继承（父类）在前，实现（接口）在后；顺序不可颠倒； 
   java.io.Serializable：未实现此接口的类将无法使其任何状态序列化或反序列化。为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。 
   java.lang.Cloneable：表明 Object.clone() 方法可以合法地对该类实例进行按字段复制.实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的）。如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常。 
   java.util.RandomAccess：用来表明其支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。 
   java.rmi.Remote：Remote 接口用于标识其方法可以从非本地虚拟机上调用的接口。任何远程对象都必须直接或间接实现此接口。只有在“远程接口”（扩展 java.rmi.Remote 的接口）中指定的这些方法才可远程使用。 
   
  接口只能用public修饰，抽象类不能用private访问修饰符；抽象类的速度运行要更快；接口的方法都是public abstract，属性是 public static final 的常量； 
  接口可以理解成统一的协议, 而接口中的属性也属于协议中的内容。但是接口的属性都是公共的，静态的，最终的。 
  接口的成员特点： 
   
   1、成员变量只能是常量，默认修饰符 public static final 
   2、成员方法只能是抽象方法。默认修饰符 public abstract 
   
  所以，Java 接口中，使用变量的时候，变量必须被赋值。 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hjFkZjkP-1601419337310)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912123629496.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OwdzSgdB-1601419337310)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912124416870.png)] 
  普通类有构造方法和方法体；抽象类有构造方法但是没有方法体；接口不是类，没有构造方法；但是接口可以有抽象方法和静态最终变量； 
  内部类 
  内部类优点和缺点： 
   
   优点：可访问外部类私有属性（心脏可访问身体的血液，而不是外部抽血）。 
   缺点：破坏原有类的程序结构（属性、构造方法、普通方法、内部类） 
   
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8sRV77AC-1601419337311)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912124750453.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rnV3KAZK-1601419337313)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912125030497.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KuAJjwWW-1601419337314)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912125233896.png)] 
  内部类可以获得外部类的私有属性和方法（也可以获得外部类的公共属性和方法）;内部类变为静态的就无法获得了，因为静态先执行，比外部类更早执行；如果静态内部类还想要获得外部类的属性和方法，那么外部类也必须定义为静态的才可以； 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t8JW9ZHF-1601419337314)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912125811636.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B0UWEDNK-1601419337315)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130039091.png)] 
  异常 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nVR8RtbD-1601419337316)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130125761.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NuigxU25-1601419337317)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130259975.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rshBEItf-1601419337317)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130507620.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jfEymoXh-1601419337318)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130623419.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NbvsLHll-1601419337319)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130728044.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JKBQt8FQ-1601419337319)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912130811560.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m2TTXck3-1601419337320)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912131214200.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6hwgO4DI-1601419337321)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912131349740.png)] 
  a方法调用b方法，b方法调用a方法，是错误不是异常 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwGCVKC1-1601419337322)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912131859051.png)] 
  ctrl+alt+T。ide选中的快捷键T 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-10Jlq0lK-1601419337322)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912132146735.png)] 
  主动抛出异常throw，方法体内部；被动方法参数列表后throws 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BqMGND47-1601419337323)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912132609557.png)] 
  自定义异常 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SBo8KGlC-1601419337324)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912132801727.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9tXFyv4a-1601419337324)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912133341138.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1DpKJc7r-1601419337325)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912133527653.png)] 
  方法名命名规则；
 1，查询，getObjiectByid(Int id);//通过什么属性遍历需要传参；
 布尔类型是否存在需要传参 isTitleIsExists(String title);
 2不用下标时可以使用foreach语法，先进行非空判断，再循环输出；
 查找时，如果查到，是特定值【不是教练等属性分级一类的话】要用break，及时结束判断；
 3添加时需要传参，首先，建立对象；删除时，传参，传要删的类的属性；
 4添加时，复制数组获得非空值的最大下标，然后复制非空最大值加1；用添加的对象给新的数组非空值进行赋值 ，其下标是getMax(),即原数组的实际长度最大值；
 5String 大写原因是因为String是类，不可继承的最终类；
 6equals 是判断内容是否相等，地址；==判断是值；contains是包含，可以进行模糊查询；
 7.String 方法：length():数组长度方法，返回int
 char x=Str.charAt(下标); indexof(Str)=-1不存在
 substring（）截取字符串；截取字符串方法都是小写；substring(int index)前开后闭；substring(int beginindex,intendindex)字符串截取下标的开始结尾
 split（）分割，返回数组；以。进行分隔符分割返回一个数组；String[]arr=str.slplit(“-”)；
 join(）连接数组 join(“.”,数组名称arr) 返回一个对象 Sting newStr=String.join(分隔符)
 concat另外一个字符串的内容) “李白”concat(“诗仙”)；
 8带参方法注意是否内部还是外部调用；外部调用，需要先建立对象再进行调用；如果是在类内部，可以直接调用
 9；调用带参方法注意事项是否内部还是外部调用；外部调用，需要先建立对象再进行调用；如果是在类内部，可以直接调用；
 10.非空值判断做联合条件判断时永远写在首位，否则删除时肯能会出现空指针异常； 
   File类中有两个方法可以用来创建文件夹：

    mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
    mkdirs()方法创建一个文件夹和它的所有父文件夹
 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LVRAJwu2-1601419337326)(Java基础面向对象/image-20200929091920529.png)] 
  因子为0.5访问效率最高，1时空间利用率最大，0.75刚好兼顾，达到平衡点 
  value值可以相同，set无序唯一 
  日志工具的导入 
  1.maven仓库中下载架包；找到jar包名，然后点击版本号进行下载； 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t3C1tZY5-1601419337326)(Java基础面向对象/image-20200929120109456.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H5ugIUFu-1601419337327)(Java基础面向对象/image-20200929120154256.png)] 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XKwizmED-1601419337327)(Java基础面向对象/image-20200929133313300.png)] 
  2.在工程名上右键，建立lib文件夹。并把log4j导入到lib中 
  3，进入lib包中，右键jar包点击buildpath–addtopath 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xKr4SAP2-1601419337328)(Java基础面向对象/image-20200929115759273.png)] 
  代码提示）功能扩展取代Alt+/,设置自定义快捷键 
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gEGaTNkR-1601419337329)(Java基础面向对象/image-20200929171646174.png)] 
  在java activation triggers for java 中输入.a-zA-Z【里面输入26个字母】代码提示）功能扩展点击应用关闭就可以了

java面向对象oop阶段总结

名词解释

4.多态的具体运用

8.光标变为十字架取消：alt+shift+a

显示菜单方法的两种思想【循环/递归】

new Date()

exit(0/1)系统正常/非正常退出

变量

成员变量和类变量的区别：

数组的缺陷

日期下单时间

Compareto

javadoc命令生成帮助文档

包按层显示

初始化信息initial

方法

隐式构造vs显示构造

返回值return

值比较和地址比较

生成银行卡号随机数

判断密码是否符合规定flag

String

String str1 = “abc”; String str2 = “ab”; String str3 = str2 + “c”; str1==str3是false吗？

StringBuffer 方法

构造方法

compare to排序：

类的成员变量、构造函数、成员方法的初始化过程

面向对象程序设计

Swith修改多个参数的类型

int类型进行三元判断

类的属性转化为字符串

instanceof进行ToString判断

封装

junit的使用方法

loombook的使用方法：

类图安装与使用

[parseInt()]转化为整型

日期转换

getset方法

使用getset后，有参构造方法也要记得修改

根据索引查找单条信息

查询总条数

分页方法

查找当前页信息

获得索引方法

获得非空索引的最大下标

应用：看队员的随机技能，冒泡排序，查找某类型的球员

查看所有

查看某种

添加

删除

报废

修改

查找是否存在

获得随机数

归还东西【根据编号查找】

退出

重载

继承

this

成员变量和局部变量

面向对象

形参（定义方法时的形式参数）实参（调用时使用的参数）

递归要有边界，否则死循环；实际上不断调用自己

Java内存.数组本身就是对象，存储在堆中

new的本质就是在调用类的无参构造，通过new方法对对象实例化[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7xRCIDT1-1601419337292)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20200912094238138.png)]

封装[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TpEOcwBJ-1601419337293)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912103215638.png)]

1继承时，父类不是私有才能调用否则报错）

不能继承final类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vTi6xKGG-1601419337299)(Java%E5%9F%BA%E7%A1%80%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/image-20200912105207221.png)]

多态【动态编译：可扩展性】

多态的优点

多态存在的三个必要条件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gockScwe-1601419337302)(Java基础面向对象/image-20200924222924165.png)]

重写

Instanceof大包含小（ 大 《属于————小）

static静态

类

抽象类

抽象类总结规定

Instanceof大包含小（大《属于————小）