在以前基础语法中，重点思维逻辑,所有的知识点就跟以前数学中的公式是一样的。
难点就是如何使用这些知识点
学习方法就要做一个简单的改变。
如果你代码写多了，你会发现一个特点，不管题目怎么变，代码都是八九不离十,代码相似度很高。
1，理解概念。
2，写代码。
在面向对象这一章节中，一定要做这件事情
"把理解概念为首要目标"
面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细处理每一个细节—强调步骤
面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具有该功能的人,来帮我做事儿—强调对象
特点:
1面向对象思想是一种更符合我们思考习惯的思想,他可以将复杂的事情简单化,并将我们从执行者变成了指挥者
2面向对象的语言中,包含了三大基本特征,封装 继承和多态.
使用面向对象:
System.out.println(Arrays.toString(array));
找一个JDK给我们提供好的Array类
其中有一个toString方法,直接就能把数组变成想要的格式的字符串
1-面向对象思想的概述
面向过程：
侧重点： "步骤"
所有的步骤都需要我们自己一步一步的实现。
面向对象：
侧重点："调用"
我们想要完成一个功能，此时就不需要我们自己手写了。
直接调用别人已经写好的代码就可以了。
2-面向对象思想的举例
面向对象，自己不干了，找别人。
例如:
你如何使用面向过程的方式找女朋友，
1，务色。
2，舔着个大脸去要微信号。
3，尬聊
4，约出来看电影，吃饭...
5，成了。
面向对象的方式找一个女朋友呢？
你只要打开淘宝，调用其中的发货功能，那么你就会有一个女朋友了。
你是否关心，你如何拥有的？
我不关心，我只要调用别人已经有的功能（方法），就可以了。
我不关心，我调用的那个方法是如何实现的。
3-类和对象的关系
类:是一组相关属性和行为的集合.可以看成是一类事物的模板,使用事物特征和行为特征来描述该类事物
属性:就是该事物的状态信息(是什么)
行为:该事物能够做什么
成员变量(属性):以人为类-姓名,性别,年龄
成员方法(行为):以人为类-吃饭,睡觉,
对象:是一类事物的具体表现,对象是类的一个实例,必然具备该类事物的属性和行为.
女朋友 //描述--- 对应着Java中的类。
有一双漂亮的眼睛。
有一双漂亮的耳朵。
有一个漂亮的鼻子。
温柔，大方，不发脾气。
可以把她的脏衣服给你。
可以让你去做饭。
可以让你提交你的工资卡。
可以一个月给你200块零花钱，有的时候还忘记。
类和对象的关系
1 类是对一类事物的描述,是抽象的
2 对象是一类事物的实例,是具体的
类是对象的模板,对象是类的实体
等你实际的按照上面的描述标准去找到的女朋友。
才是真正的对象。 --- 在Java中还有一个名词(实体)
"对象，实体" --- 他指的是同一个东西。
4-类的定义
如何定义一个类。
事物与类的对比
现实世界的一类事物
属性:事物的状态信息
行为:事物能够做什么
JAVA中用class描述的事物也是如此
成员变量:对应事物的属性
成员方法:对应事物的行为
类的定义格式
定义类就是定义类的成员,包括成员变量和成员方法
成员变量(属性):和以前定义变量几乎是一样的,只不过位置发生了改变,在类中,方法外
成员方法(行为):和以前定义的方法是一样的,只不过把static去掉,static的作用在面向对象后面的课程中再详细讲解
1，成员变量
定义在方法外，类的里面。
定义变量的时候，没有写赋值。
2，成员方法
不加 static 关键字。
类：是对事物的描述。
这个事物，什么被定义成成员变量
什么被定义成成员方法？
成员变量：
属性。。。
//这类事物本身有什么特点。
classworker{ //工人
//属性
姓名
年龄
性别
工号
职务
特长
//行为
工作
吃饭
睡觉
}
class程序猿{
//属性
姓名
年龄
性别
//行为
写代码()
改变世界( ){
}
成员方法：
行为。。。
//这类事物本身能干什么？
例子: public class student { String name;//----------------成员变量 int age; //------------------------------成员变量 public void eat(){//--------------------成员方法 System.out.println("吃饭饭!"); } public void sieep(){//-------------------成员方法 System.out.println("睡觉觉!"); } public void study(){//-------------------成员方法 System.out.println("学习!"); } }
注意:
1:成员变量是直接定义在类当中的,在方法外边
2:成员方法不要写static关键字
5-对象的创建及其使用
如何使用一个类
通常情况下,一个类并不能直接使用,需要根据一个类创建一个对象,才能使用
1，导包 : 也就是指出需要使用什么类,在什么位置
a,如果在同一个包下就不需要导包。
b,在java的lang包下也不需要导包
//java自己也给我们开发者提供了各种各样的类。以便我们开发。
//不可能把所有的类都放在同一个包中。
//其中有一个包名 lang 表示这个包是java的核心包
import包名称,类名称
importcn.itcast.day01.demo01.Student;
对于和当前类属于同一个包的情况,可以省略导包语句不写
问：
如何看一个类是否在java的lang包下呢？
这个知识点到学习java的api的时候再进行解释。
2.创建对象
格式:
类名称对象名 = new 类名称();
Student stu = new Student();
//Student类 就是对学生这个事物的描述
//现在我new出来的这个对象，就实际的表示一个学生。
Studentstu = new Student();//在java代码中表示的学生对象（学生实体）
//如何表示王嘉伟同学呢？
Studentstu = new Student();
stu.name= "王嘉伟";
stu.age= 17;
3，使用成员变量，成员方法
使用成员变量:(格式)对象名.成员变量名
使用成员方法:对象名,成员方法名(参数)(也就是想用谁就用对象名点谁)
当我们创建了这个类的对象的时候，
那么我们可以通过这个对象来调用这个类中的方法和成员变量。
"其他类中的成员变量和成员变量，是不能通过这个对象来调用的。"
classStudent{
name
publicvoid eat(){
System.out.println("今天中午吃猪蹄");
}
}
classWork{
id
publicvoid work(){
System.out.println("工人在工作");
}
}
Students = new Student();
s就是学生对象，我们可以通过这个学生对象来调用Student类中的成员变量name 和成员方法 ea
但是不能
用s这个学生对象，去调用 Work类中的id和 work
注意事项: // 如果成员变量没有赋值,那么将会有一个默认值,规则和数组一样 实操: student stu = new student();//--------创建格式 System.out.println(stu.name);//----使用成员变量 System.out.println(stu.age); stu.age = 18;//----------------------改变对象中成员变量的数值内容 stu.name = "刘亦菲";//--------将右侧的字符串赋值交给stu对象中的name System.out.println(stu.name); System.out.println(stu.age); stu.eat();//---------------------使用对象的成员方法,格式 stu.sieep(); stu.study();
六,-一个对象的内存图
惊讶的发现，跟数组一毛一样的。
凡是new 出来的，都是在内存中出现的。
只要是new一次，都是重新在堆里面开辟了一个空间。
七-使用对象类型作为方法的返回值:
当使用一个对象类型作为方法的返回值时
返回值其实就是对象的地址值
成员变量和局部变量的区别:
1,定义的位置不一样[重点]
局部变量:在方法的内部
成员变量:在方法的外部,直接写在类中
2,作用范围不一样[重点]
局部变量:只有方法之中才可以使用,出了方法不能用
成员变量:整个类全都可以通用
3,默认值不一样[重点]
局部变量:没有默认值,如果想要使用,必须进行手动赋值
成员变量:如果没有赋值,会有默认值,规则和数组一样
4,内存的位置不一样[了解]
局部变量:位于栈内存
成员变量:位于堆内存
5,生命周期不一样[了解]
局部变量:随着方法进栈而诞生,随着方法出栈而消失
成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失
PS通!常!情!况!下,局部变量的生命周期跟着方法走短一些
成员变量的生命周期跟着对象走长一点
面向对象的基本概念：
面向过程与面向对象的区别：
面向过程：侧重的是过程，强调代码是一步一步的进行的。所有的工作都是需要我们自己做的。
面向对象：侧重的是对象的调用，如果我们需要完成一个功能，那么不需要自己写，我们直接去调用已经写好的代码就可以了。
我们是不关心调用的方法中具体是什么逻辑的。
类，对象。
类： 是对一类事物的描述。 并不能指具体的某一个对象。
classDog{ //用来描述狗的一个类。并不能直接表示是哪一条狗。
}
对象：才是一个事物的具体表现。
Dogd = new Dog(); //品种 ，年龄
该如何定义一个类，该如何使用一个类。
publicclass Dog{
//属性 --- 我们是以成员变量的形式体现的。
Stringcolor;
intage;
//行为 --- 我们是以成员方法的形式体现的。
publicvoid eat(){
...
}
publicvoid lookHome(){
...} }
如何使用一个类？
创建这个类的对象。
Dogd = new Dog();
8-两个对象使用同一个方法的内存图
创建两个数组的内存图是一模一样的
结论：
每new一次都是一个独立的空间，互相没有影响。
每一个空间里面，都有各自的成员变量。
9-两个引用指向同一个对象的内存图
结论：
当多个引用指向同一个对象的时候，
只要其中一个引用对这个对象发生了改变，
那么所有的引用再去访问这个对象时，就是改变之后的结果了。
10-使用对象类型作为方法的参数
使用对象类型作为方法的返回值:
当使用一个对象类型作为方法的返回值时
返回值其实就是对象的地址值
之前我们在调用方法的时候更多的时候是把基本数据类型传递。
结论：
"当方法的形式参数是基本数据类型时，此时我们传递是值。 "
"当方法的形式参数是引用数据类型时，此时我们传递是对象的地址值。"
引用数据：简单记：除了8种基本数据类型其他所有的都是引用数据类型。
其实就是在堆里面开辟了一个空间（凡是new出来的都是引用数据类型
结论：
当方法的形式参数为引用数据类型的时候，
如果在方法中对对象进行了改变，
那么所有的地方(main)都会发生改变。
public static void main(String[] args) {
Phone one(0x0011) = new Phone();(0x0011)
one(0x0011).brand = "苹果";
one(0x0011).price = 8388.0;
one(0x0011).color = "土豪金";
method(one); // 传递进去的参数其实就是地址值
(0x0011)
System.out.println(one.brand);//小米
System.out.println(one.price);//899
System.out.println(one.color);//黑色
}
public static void method(Phone param) {//引用数据类型
//param接收了传递进来的地址值，那么param也可以通过这个地址值找到上面开辟的那个空间
//param接收到的就是 0x0011
System.out.println(param(0x0011).brand); // 苹果
System.out.println(param(0x0011).price); // 8388.0
System.out.println(param(0x0011).color); // 土豪金
param.brand= "小米";
param.price= "899";
param.color= "黑色";
}
11-使用对象类型作为方法的返回值
public static void main(String[] args) {
Phone two = getPhone();
System.out.println(two.brand); // 苹果
System.out.println(two.price); // 8388.0
System.out.println(two.color); // 玫瑰金
}
public static Phone getPhone() {
Phone one = new Phone();
one.brand = "苹果";
one.price = 8388.0;
one.color = "玫瑰金";
return one;
}
通过以上的两个知识点：
"方法需要什么，我们就给什么"
"方法返回什么，我们就用什么去接收"
12-成员变量和局部变量的区别
作用范围 --- 生命周期
//只要这个变量活着的时候，就可以被使用
小明家有一条狗，这条狗是一只母狗。有一天小狗怀孕了。
小红问小明，你家的狗生了吗？
小明说："未生出"。
未:
位置
---代码中的位置
//成员变量，类中，方法外。 局部变量，方法里面或者方法声明上（形式参数）
---内存中的位置
//成员变量，当创建对象时，new出来的小空间里面。
//局部变量，栈的对应的方法里面。
生:
生命周期（作用范围）
//成员变量：当对象开始创建的时候开始存在，当对象变成垃圾就消失了。
//局部变量：从局部变量开始定义的时候才出现，
// 当代码执行到局部变量所在的右大括号的时候。就消失了
出:
默认初始化值
//成员变量是有默认初始化值。整数：0 小数（浮点数） 0.0
// 引用：null
//局部变量没有默认初始化值，如果想要使用，一定要先赋值才能使用。
13-面向对象三大特征之封装性
面向对象的三大特征:封装,继承,多态
封装性在java当中的体现:
1,方法就是一种封装
封装性在Java当中的体现：
1.方法就是一种封装 --- 侧重于调用，而忽视方法的实现细节。
//好处：
//1，提高了代码的复用性。 --- 我们想要用的时，直接调用就可以了。
//2，提高了代码的可维护性。 --- 当我们后续想要修改逻辑时，只要修改方法中的代码就可以。调用处我们就不需要改。
2.关键字private也是一种封装
私有化成员变量。
为什么要私有化成员变量。
为了保证数据的安全性。不让外界直接使用对象点去调用。
封装就是将一些细节信息隐藏起来,对于外界不可见
外界就已经不能直接访问了，但是成员变量一定要被赋值，否则是没有意义的。
所以我们又写了一个setXxxx 和getXxx的方法用来获取和设置值。
"通过这样的方式又能保证数据的安全性，又能对成员变量进行赋值。"
一旦使用了private进行修饰,那么本类中仍然可以随意访问
但是!超出了本类范围之外就不能再直接访问了
间接访问private成员变量,就是定义一堆getter/setter方法
必须叫setXxx或者是getXxx命名规则
对于Getter来说,不能有参数,返回值类型和成员变量对应
对于Setter来说,不能有返回值,参数类型和成员变量对应
classStudent{
privateString name;
publicvoid setName(String n){
name= n; }
publicString getName(){
returnname;
}
}
//如果我仅仅是想修改值还好。
//Students = new Student();
//s.setName("老王");
//------
//我仅仅只想获取值，怎么办？
class Student{
privateString name;
publicString setName(String n){//李四
name= n;
returnname;
} }
//所以 set和get方法一定一定要分开写。
publicprivate 这两个关键字的特点
也称之为权限修饰符。
public: public 可以修饰类，可以修饰方法，可以修饰成员变量。
当修饰类的时候，类名一定要跟文件名保持一致。
当修饰方法和成员变量时，在其他任何包，任何类中都可以进行调用。（只要是在同一个项目下） private:修饰方法和成员变量。
只能在本类中被访问。
以上就是要求大家掌握的两种权限修饰符。
封装就是将一些细节信息隐藏起来，对于外界不可见。
构造方法
构造方法是专门用来创造对象的方法,当我们通过关键字new来创建对象时其实就是在调用构造方法
格式:
public 类名称(参数类型参数名称){
方法体 }
例子:
public student (){
system.out.println("构造方法使用了");
}
注意事项:
1,构造方法的名称必须和所在的类名称完全一样,就连大小写也要一样
2,构造方法不要写返回值类型,连void都不要写
3,构造方法不能return一个具体返回值
4,如果没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数没有方法体什么事情都不做.public student(){}
5,一旦编写了至少一个构造方法,那么编译器将不再赠送.
6,构造方法也是可以进行重载的
重载:方法名称相同,参数列表不同
定义一个标准的类(student为例)
一个标准的类通常拥有下面四个组成部分
1,所有成员变量都要使用private关键字修饰
2,为每一个成员变量编写一对Getter/Setter方法
3,编写一个无参数的构造方法
4,编写一个全参数的构造方法
这样的标准类也叫做 Java Bean
//--------------------------------
面向对象的特点：
可以简化了我们代码的书写。
//当我们需要什么什么功能的时，我们不需要自己手动的写代码
//可以使用java提供好的类，调用里面对应的方法就可以了。
学习的最为主要的知识点:
如果写一个类去描述一个学生对象。
//也会统称为 javabean类。实体类。
publicclass Student{ //类名要跟你描述的那个群体保持一致。"见名知意。"
//成员变量 --- 用来描述学生的属性。
//姓名，年龄，性别，学科。
privateint age;
privateString gender;
privateString subject;
//为了解决外界可以赋值这样的操作。
//针对于每一个私有化的成员变量，要提供其对应的get和set方法。
//如果有10个私有化的成员变量
//是不是仅仅是get和set方法一共就要提供20个呢？
//是的。
利用idea 自动生成 get和set方法.
//成员方法 ---- 用来描述学生的行为，说明了学生可以做什么
如何创建这个类去调用这个类里面的方法。
//在别的类中创建javabean类的对象，那么别的类，我们一般也会称之为 测试类。
//一般会在测试类中写main方法。
//会在测试类中创建javabean类的对象，并进行赋值调用等。
是在别的类中创建Student类的对象。
Students = new Student();
s.setName("张三");
Stringname = s.getName();
s.study();
//---------------------------------------------------
16-this关键字的作用
this关键字的作用
当方法的局部变量和类的成员变量重名的时候,根据就近原则,有限使用局部变量
如果需要访问本类当中的成员变量,需要使用格式
this.成员变量名
重点:
"通过谁调用方法,就就是this-主要就是在重名的情况下起到区分的效果"
在java代码中，使用变量的一个就近原则：
谁离我近，我就用谁。
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
System.out.println(a);//首先去当前方法的局部位置找有没有定义变量a
//如果局部位置没有变量a，那么就到本类的成员位置去找。
//等学习了继承之后，还会继续找，一直找不到才会报错。
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名
“通过谁调用的方法，谁就是this。”
this关键字
classStudent{
Stringname;
publicvoid say(String name){
System.out.println(this.name);
}
}
//问：
//方法里面 name
//成员位置 name
//为什么没有报错？
//为什么局部变量跟成员变量重名的时候，没有报错？
//内存。
//成员变量在内存中，堆里面，创建对象的那个小空间中。
//局部变量在栈里面，当方法加载到栈里面的时候，才会定义一个局部变量
//如何定义变量不会因为重名而报错。
"在内存中，不要在同一个空间中。"
this:
"通过谁调用的方法，谁就是this"
---
"谁来调用我，我就代表谁"
我们可以把this理解成一个变量，记录的是当前调用方法对象的地址值。
"谁来调用this所在的方法，那么此时this就代表这个对象的地址值。"
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名
问：
1，构造方法有什么作用？是被谁调用的？
在创建对象时，给成员变量进行赋值的。
不是我们手动调用的，而是在创建对象的时候，虚拟机会根据你小括号的参数，来决定调用哪个构造方法。
2,既然构造方法可以用来赋值，那么set也可以用来赋值。
构造方法赋值更为的简单。
Students = new Student("zhangsan",23,"男");
Students = new Student();
s.setXXX
s.setXXX
s.setXXXX
既然更简单，那么我们还用set方法干嘛？
构造方法只能在创建对象的时候进行赋值。
Students = new Student("zhangsan",23,"男");
s= new Student("lisi",23,"男"); //把zhangsan干掉，重新创建了一个对象。
结论：
"构造方法只能在创建对象的时候赋值。"
"set方法准确的来说。 修改值。"
18-定义一个标准的类
定义一个标准的类(student为例)
一个标准的类通常拥有下面四个组成部分
1,所有成员变量都要使用private关键字修饰
2,为每一个成员变量编写一对Getter/Setter方法
3,编写一个无参数的构造方法
4,编写一个全参数的构造方法
这样的标准类也叫做 Java Bean
自动生成javabean类的快捷键：
//以后写一个标准的 javabean类
//创建类
在project界面，按 alt + Insert （alt + fn +Insert）
//1，私有化成员变量
自己手动写
//2，生成空参构造
在代码编辑区域，按 alt + Insert，选择第一个构造
按两下tab键后按回车
第一次tab：取消默认选择。
第二次tab：选择ok右边的 selectnone
//3，生成带全部参数的构造
在代码编辑区域，按 alt + Insert，选择第一个构造
按住shift不要松，选择全部的成员变量 后 回车
//4，针对于没有私有化的成员变量都要提供get和set方法
在代码编辑区域，按 alt + Insert，选择get and set
按住shift不要松，选择全部的成员变量 后 回车
//5，show方法。
手动写，将所有的成员变量都拼接在一起。