面向对象阶段回顾

1，类和对象
面向过程>面向对象
面向过程/面向方法/面向函数/j结构化方法：需要什么代码就写什么代码，代码需要复用演变出 方法为基本单位。
访问修饰符 返回值类型 方法名（形式参数列表）{
//方法体
}

面向对象：把功能进行聚合，以类和对象为组织单元进行 结构编程。
public class xx{
//模拟学生上学的方法
起床 穿衣 洗脸刷牙 上学
//模拟老师上班的方法
起床 上班

	  public class xx{
	  //调用学生的方法
	  //调用老师的方法
	  }
	  public class Student{
	  //学生的信息
	  //学生起床方法
	  //学生穿衣方法
	  }
	  public class Teacher{
	  //老师起床方法
	  //老师上班方法
	  }
生活中的类和对象
万物皆对象：所有的事物都可以看作是一个对象。
描述生活中的对象通过对象的特征和行为进行描述。
分类：生活中我们习惯会进行分类，是按照一组对象的特征和行为抽象出来的。
类和对象的关系：类是对象抽象出来的一个概念，而对象是类的一个实例，个体（根据类的模板而产生的）。
计算机的类和对象
JAVA是一个面向对象的编程语言，它将现实生活中的类和对象进行改造，以类为基本的项目组织单位。
public class 类名{
		//一组特征（属性？成员变量/实例变量）
		public Strinng name;
		//一组行为（方法/函数/成员方法）
		public void print(){
		}
	}
	//对象的创建
	类名  对象名 = new 类名（）；
	//对象属性的使用
	对象名.属性名 = xxx;
	//对象方法的调用
	对象名. 方法名；

方法的基本使用
//方法声明
访问修饰符 返回值类型 方法名（形式参数列表）{
//方法体
}
无参无返 方法的使用
public void 方法名（）{
//方法内容
打印订单信息
}
//调用方法
方法名（）；

// 1.在同一个类中 方法间的调用
//1.1 都是实例/普通成员方法
直接方法名（）调用即可
//1.2其中一个是静态的方法
静态方法无法直接调用实例方法
静态方法可以直接同1.1调用静态方法
实例方法可以直接调用静态方法

//2.在不同类中 方法间调用
//2.1 调用其他类的实例方法
先创建对象 然后再调用该方法

2.方法和方法重载
方法的四大分类
一，无参无返：往往用于固定的功能实现，且无需使用其实现结果的情况
//out. println()；
public void 方法名（）{
//方法体
}
二，无参有返：往往用于固定的功能实现，需要使用其实现结果的情况。
//input.nextInt();
public 返回值类型 方法名（）{
//方法体
return 返回值；
//return结束当前方法 返回到方法的调用位置
}
三，有参无返：需要根据参数来进行相应处理，处理完的结果无需再次被使用
//Arrays.sort(数组）；调用完方法 数据已经排序结束
无需返回结果
public void 方法名（形式参数列表）{
//方法体
}
有参有返：需要根据参数来进行相应处理，并且处理完的结果需要再次使用。
//String Arrays.toString(数组）；
public 返回值类型 方法名（形式参数列表）{
//方法体
return 返回值；
}
方法的参数为基本数据类型和引用数据类型
方法的参数为基本数据类型：传递的值的内容，传递过去之后与之前无关。
方法的参数为引用数据类型：传递的是地址值。传过去之后多方引用同一块内容。
构造方法
Student stu = new Student();
student();
构造方法的作用 用于对象的初始化。
//构造方法默认是系统自动提供的（无参构造）
//如果你自行定义了一个构造方法 则系统不再提供了
public 类名（）{
//初始化内容
}
//带参构造
public 类名（String name,int age）{
//给成员变量赋值
//stuName = name;
//stuAge = age;
this.name = name;
this.age = age;
}
this关键字
this表示当前对象，谁在调用方法 谁就是当前对象。
this是对象 所以对象可以调用的它都可以调用。
this，属性名
this，方法名
this（）；//调用构造 它必须出现在构造方法中方法中的有效代码的第一行。
成员变量和局部变量的区别
如果成员变量和局部变量重名，通过this来进行区分。（python用global）
定义的位置：
成员变量定义在类中方法外。
局部变量定义在类中方法内。
作用域：成员变量在整个类中都有戏。
局部变量只在定义它的方法内有效。
生命周期：成员变量随着对象的创建而产生，随着对象的销毁而终结。
局部变量随着方法的压栈而产生，随着方法的弹栈而结束。
默认值：
成员变量有默认值，在对象创建时进行了初始化。
局部变量没有默认值，如果不赋值无法直接使用。
方法重载
在同一个类中，如果出现了方法名相同，参数列表不同的情况，则构成了方法重载，与返回值类型和访问修饰符无关。
public void method1(){
}
public int method1(int age){
}
3.封装 三大特性之一
封装的作用
Dog dog = new Dog();
dog.age = 200;
1.int类型取值范围
2.添加判断方法 但是因为属性可以被任意访问，所以判断方法无法强制生效。

public class Dog{
//public int age = if (age > 1)
public int age;
public void setAge(int age){
if(age > 15 || age < 0){
this.age = 1; //进行不合理赋值处理
}else{
this.age = age;
}
}
}
封装的使用
1.属性私有化
2.提供公共的setter getter方法
3.根据需求在getter setter方法中添加逻辑控制语句。
public class Dog{
private int age; //以前 new Dog(). age
public void setAge(int age){
//判断
this.age = age;
}
public int getAge(){
return this.age;
}
}
Java Bean规范（了解）
1.属性私有化
2.提供公共的getter setter方法
3.提供无参构造
4.实现序列化接口 serializable
包package
可以用于在一个项目出现多个重名的类文件
可以用于在一个项目中更清晰的对类文件进行区分。
可以用来做访问权限控制。
包的命名规范：全部小写，根据公司域名倒叙和公司内部规范来进行命名。
如果在包下定义类，那么此类中应该进行包声明。
package 包名
如果两个类在同一个包中，可以直接使用。
如果两个类在不同包中，必须要先导包才能使用。（java.lang包下的类无需导入）
原因：因为不同包中可能有重名的文件，如果不指定类路径/全类名（cn.kgc.Test）,编译器无法区分。
import要导入的类的全类名/全限定名/类路径。
注意：如果在一个中使用到两个不同包的同类名，那么必然有一个是需要以全类名形式使用的。
cg.kgc.demo1.Test1 test1 = new
cg.kgc.demo1.Test();
关键字static
静态的 类的
如果添加了static关键字，则此成员成为类的信息。
static学生的信息和普通实例信息的区别：
1.static修饰的是属于类的，它被类的所有对象共享。
普通实例信息是对象之间相互独立的。
2.static修饰的信息是随着类的加载而加载，而普通实例信息是随着对象的创建而产生。
static可以用来修饰属性，方法，代码块。
成员/实例/构造/非静态代码块：{ //代码内容}
静态代码块：static{}
4.继承-三大特性之一
public class Dog{
private String name;
private int health;
private int love;
private String strain;
public void print(){
syso(name heath love);
}
}
public class Cat{
private String name;
private int health;
private int love;
private char gender;

		p blic void print(){
		syso(name health love);
		}
	}
	继承：为了实现代码复用而产生的。java继承是单根继承。
	一个子类有且仅有一个父类，默认的父类是Object类。
	父类：子类共有代码的聚合体。
	子类：继承了 公有代码聚合体的类。
	子类 is a 父类
		public class Pet{
			//公有代码
			}
			public class Dog extends Pet{
				//继承了公有代码
				//特有的代码
				}
				子类并不能继承所有的父类信息：
		1. 私有的 private修饰的
		2. 构造的 构造方法
		3. 不同包时默认修饰的（如果父类和子类不同包，但是父类中的某个信息还想被子类继承。必须加上protected修饰 ）
		public class Pet{
			String name;
			}
			public class Dog extends Pet{
				public Dog(){
					supper();
					}
				}
		super关键字
		表示当前类的父类对象
		super.属性
		super，方法（）
		super（）作用是？
		当拥有继承关系之后，子类在调用构造时，会自动调用父类的无参构造。
		5.方法的重写
		在子类继承了父类的方法之后，如果觉得父类的方法不太强，可以根据需求进行重写。
		@override 注解     推翻
		方法重写和重载的区别
		重写发生在继承关系的子类中。
		重载发生在同一个类中。
重写：方法名相同，参数列表相同，返回值类型相同或者为其子类（多态），访问修饰符不能严于父类，抛出的异常不能比父类更大更多。
重载：方法名相同，参数列表不同，与返回值类型和修饰符无关。
JDK中的重写作用
Object类：超类 祖宗类 superlass 每一个类都直接或间接继承自Object.
equals(); (我们是在字符串作比较时认识的）
	public boolean equal(Object obj){
		return(this == obj);
toString(); (out.print() 它底层在调用你输出内容的toString()方法）
public String toString(){
	return getClass().getClass().getName() + "@" +Integer.toHexString(hashCode());
	}