1.Java类及类的成员:属性、方法、构造器；代码块、内部类
2.面向对象的三大特征:封装、继承、多态、（抽象）
3.其它关键字:this、super、static、final、abstract、interface、package、import等
大处着眼，小处着手 二.思想解析：“人把大象装进冰箱” 1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。①把冰箱门打开
②抬起大象，塞进冰箱
③把冰箱门关闭
2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。①人（类）
②冰箱（类）
③大象（类）
三.面向对象的两个要素:类:对一类事物的描述，是抽象的、概念上的定义
对象:是实际存在的该类事物的每个个体，因而也称为实例(instance)
①面向对象程序设计的重点是类的设计 ②设计类，就是设计类的成员。属性=成员变量= field =域、字段
方法=成员方法=函数= method
创建类的对象=类的实例化=实例化类
四.类和对象的使用（面向对象思想落地的实现)1.创建类，设计类的成员
2.创建类的对象
3.通过“对象.属性"或对象.方法"调用对象的结构
public class PersonTest {
public static void main(String[] args) {
//创建Persion类的对象
Persion p1 = new Persion();
//调用对象的结构：属性、方法
//属性
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//方法
p1.eat();
p1.sleep();
p1.talk("Chinese");
}
}
class Persion {
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat(){
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人可以睡觉");
}
public void talk(String language){
System.out.println("人可以说话,使用的是：" + language);
}
}
如具创建了一个类的多个对则每个对象都独立的拥有一套类的属性。(非static的)
意味着:如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
五.类中属性的使用属性(成员变量) vs 局部变量
1.相同点
1.1定义变量的格式:数据类型 变量名 = 变量值
1.2先声明，后使用
1.3变量都有其对应的作用域
2.不同点:
2.1在类中声明的位置的不同
属性:直接定义在类的一对{}内
局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2关于权限修饰符的不同
属性:可以在声明属性时，指明其权限,使用权限修饰符。(常用的权限修饰符: private、 public、缺省、protected)
局部变量:不可以使用权限修饰符。
2.3默认初始化值的情况:
属性:类的属性，根据其类型，都有默认初始化值。
整型（byte、 short、int、long) : 0
浮点型（float、 double) : 0.0
字符型（char） : 0(或'u0000')
布尔型(boolean): false
引用数据类型(类、数组、接口):null
局部变量:没有默认初始化值。
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地:形参在调用时，我们赋值即可。
2.4在内存中加载的位置:
属性:加载到堆空间中 (非static的)
局部变量:加载到栈空间
六.类中方法的声明和使用方法:描述类应该具有的功能。
1.方法的分类
2.方法的声明
权限修饰符 返回值类型 方法名(形参列表){
方法体
}
3.说明:
3.1 权限修饰符：
Java规定的4种权限修饰符: private、 public、缺省、protected
3.2 返回值类型:有返回值 vs 没有返回值
3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量。
如果方法没有返回值,则方法声明时，使用void来表示。通常没有返回值的方法中，就不使用return。但是如果使用的话，只能“return;”，表示结束此方法的意思。
3.2.2我们定义方法该不该有返回值?
①题目要求
②凭经验：具体问题具体分析
3.3方法名:属于标识符,遵循标识符的规则和规范,“见名知意”
3.4 形参列表：方法可以声明0个，1个，或多个形参。
3.4.1 格式：数据类型1 影参1,数据类型2 形参2,。。。
3.4.2 我们定义方法时，该不该定义形参?
①题目要求
②凭经验：具体问题具体分析
3.5 方法体：方法功能的体现
4.return关键字的使用:
1.使用范围:使用在方法体中
2.作用:
①结束方法
②针对于有返回值类型的方法，使用"return 数据"方法返所要的数据。
3.注意点:return关键字后面不可以声明执行语句。
5.方法的使用中，可以调用当前类的属性或方法
特殊的:方法A中又调用了方法A:递归方法。
方法中，不可以定义方法。
练习1：要求：
(1)创建Person类的对象，设置该对象的name.age和sex属性，调用study方法， 输出字符串"studying”，调用showAge()方法显示age值， 调用addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
Persion类package com.wy.exer;
public class Persion {
String name;
int age;
int sex;
public void study(){
System.out.println("studying");
}
public void showAge(){
System.out.println("age: " + age);
}
public int addAge(int i){
age += i;
return age;
}
}
PersionTest类
package com.wy.exer;
public class PersionTest {
public static void main(String[] args) {
Persion p1 = new Persion();
p1.name = "Tom";
p1.age = 18;
p1.sex = 1;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄是: " + newAge);
/
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
c1.radius = 2.1;
double area = c1.findArea();
System.out.println(area);
}
}
//圆
class Circle{
//属性
double radius;
//求圆的面积
public double findArea(){
double area = Math.PI * radius * radius;
return area;
}
}
练习3
package com.wy.exer;
public class StudentTest {
public static void main(String[] args) {
//声明Student类型的数组
Student[] stus = new Student[20];
//给数组元素赋值
for (int i = 0;i < stus.length;i++){
stus[i] = new Student();
//给Student对象的属性赋值
stus[i].number = i + 1;
//年级[1,6]
stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
//成绩[0,100]
stus[i].score = (int)(Math.random() * (100 + 1));
}
//遍历学生数组
for (int i = 0;i < stus.length;i++){
// System.out.println(stus[i].number + "," + stus[i].state + "," + stus[i].score);
System.out.println(stus[i].info());
}
System.out.println("*********************************");
//问题一:打印出3年级(state值为3）的学生信息。
for (int i = 0;i < stus.length;i++){
if (stus[i].state == 3){
System.out.println(stus[i].info());
}
}
System.out.println("*********************************");
//问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
for (int i = 0;i < stus.length - 1;i++){
for (int j = 0;j < stus.length - 1;j++){
if (stus[j].score > stus[j + 1].score){
//如果需要换序，交换的是数组的元素:Student对象! ! !
Student temp = stus[j];
stus[j] = stus[j + 1];
stus[j + 1] = temp;
}
}
}
//遍历学生数组
for (int i = 0;i < stus.length;i++){
System.out.println(stus[i].info());
}
}
}
class Student{
int number;//学号
int state;//年级
int score;//成绩
public String info(){
return "学号: " + number + ",年级: " + state+ ",成绩: " + score;
}
}
练习3优化
package com.wy.exer;
public class StudentTestYouHua {
public static void main(String[] args) {
//声明Student类型的数组
Student1[] stus = new Student1[20];
//给数组元素赋值
for (int i = 0;i < stus.length;i++){
stus[i] = new Student1();
//给Student对象的属性赋值
stus[i].number = i + 1;
//年级[1,6]
stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
//成绩[0,100]
stus[i].score = (int)(Math.random() * (100 + 1));
}
StudentTestYouHua test = new StudentTestYouHua();
//遍历学生数组
test.print(stus);
System.out.println("*********************************");
//问题一:打印出3年级(state值为3）的学生信息。
test.search(stus,3);
System.out.println("*********************************");
//问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
test.sort(stus);
//遍历学生数组
test.print(stus);
}
public void print(Student1[] stus){
for (int i = 0;i < stus.length;i++){
System.out.println(stus[i].info());
}
}
public void sort(Student1[] stus){
for (int i = 0;i < stus.length - 1;i++){
for (int j = 0;j < stus.length - 1;j++){
if (stus[j].score > stus[j + 1].score){
//如果需要换序，交换的是数组的元素:Student对象! ! !
Student1 temp = stus[j];
stus[j] = stus[j + 1];
stus[j + 1] = temp;
}
}
}
}
public void search(Student1[] stus,int state){
for (int i = 0;i < stus.length;i++){
if (stus[i].state == state){
System.out.println(stus[i].info());
}
}
}
}
class Student1{
int number;//学号
int state;//年级
int score;//成绩
public String info(){
return "学号: " + number + ",年级: " + state+ ",成绩: " + score;
}
}
七.理解“万事万物皆对象”
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
1.scanner ,strirlg等
2.文件:File
3.网络资源:URL
2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
3.引用类型的变量，只可能存储两类值:null或地址值（含变量的类型）
4.匿名对象的使用
1.理解:我们创建的对象,没有显式的赋给一个变量名。即为匿名对象
2.特征;匿名对象只能调用一次。
八.再谈方法1.方法的重载
1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
"两同一不同":同一个类、相同方法名
参数列表不同:参数个数不同，参数类型不同
2.判断是否是重载:
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
3．在通过对象调用方法时，如何确定某一个指定的方法:
①方法名
②参数列表
2.可变个数形参的方法（允许直接定义能和多个实参相匹配的形参）
1.jdk 5.0新增的内容
2.具体使用:
2.1 可变个数形参的格式: 数据类型 ... 变量名
2.2当调用可变个数形参的方法时，传入的参数个数可以是:0个，1个，2个， 。。。
2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
2.5 可变个数形参在方法的形参中，必须声明在末尾
2.6可变个数形参在方法的形参中,最多只能声明一个可变形参。
3.方法参数的值传递机制
1.关于变量的赋值:
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
2.方法的形参的传递机地值传递
1,形参和实参
1.形参:方法定义时,声明的小括号内的参数
2.实参:方法调用时,实际传递给形参的数据
2.值传递机制
1.如果参数是基本数据类型。此时实参赋给形参的是实参真实存储的数据值。
2.如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的I地址值。
4.递归方法
1.一个方法体内调用它自身
2．方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环
控制。递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
public static void main(String[] args) {
RecursionTest test = new RecursionTest();
System.out.println(test.getSum(100));
}
public int getSum(int i){
if (i == 1){
return 1;
}else {
return i + getSum(i - 1);
}
}
