第一天：
OO：面向对象
OOA：面向对象分析
OOD：面向对象设计 OOAD：面向对象分析与设计
OOP：面向对象编程
高质量的代码：
复用性好、扩展性好、维护性好、
可移植性好、健壮性好、可读性好、效率好…
1、什么是类？ 什么是对象？
类是我们自己创造的一个数据类型(引用类型)
Java给的类型有：8种基本数据类型、数组类型(引用类型)
创建对象的语法：
类、接口、数组属于引用类型，引用类型必须要new (引用类型默认值为null)
eg： 前面是什么，后面就new什么
Airplane a1 = new Airplane(); //但是 对类而言，后面一定要跟一对小()
int[ ] arr = new int[4]; //但是 对数组而言，要给 元素个数
基本类型可以直接给值 int a = 6;
1） 现实世界是由很多很多对象组成的
基于对象抽出了类
2） 对象：真实存在的单个的个体
类：类别/类型，代表一类个体
3） 类中包含：
3.1)所有对象所共有的 属性/特征 --------------- 成员变量
3.2)所有对象所共有的 行为/动作 --------------- 方法
4）一个类可以创建多个对象
同一类型所创建的对象，结构相同，数据不同
5）类是对象的模子，对象是类的具体的实例
1)2)3)举例：
对象 类
张三 学生 //从对象里抽出了类
李四
王五
马六 汽车
奥迪
奥拓
class Student{
String name;
int age;
String address;
String stuId;
void eat(){}
void sleep(){}
void study(){}
}
class Car{
String type;
String color;
double price;
void run(){}
void back(){}
void stop(){}
}
所以：
class Emp{ //雇员 --- Emp
String name;
int age;
double salary;
void print(){
System.out.println(“姓名：”+name);
System.out.println(“年龄：”+age);
System.out.println(“工资：”+salary);
}
}
4)举例：
①
Student zs = new Student(); //一旦有了对象，想访问类里的东西就 .
zs.name = “zhangsan”;
zs.age = 25;
zs.address = “陕西西安”;
zs.stuID = “111”;
zs.eat();
zs.sleep();
zs.study();
zs.abc = 250; //编译错误
②
Student ls = new Student();
ls.name = “lisi”;
ls.age = 27;
ls.address = “黑龙江佳木斯”;
ls.atuId = “222”;
ls.eat();
ls.sleep();
ls.study();
4)5)举例：
类 对象
月饼模子 月饼
//一个模子可以刻出多个月饼 (一个类可以创建多个对象)
//同一个模子所刻出来的月饼，长的都一样，面与馅不同
( 结构相同， 数据不同 )
2、如何创建类？ 如何创建对象？ 如何访问成员？
class new . (通过 引用点)
(引用)
类(数据类型) zs为 引用类型变量 指向 对象
Student zs = new Student();
Emp e = new Emp();
Emp数据类型 声明了引用变量 e
注：
a为 基本类型变量(变量)
int a;
int a = 5；//基本类型里 = 读为赋值，给变量a赋值为5
//引用类型里 = 读为 指向
把对象new Student() 存到zs里了，后面要用的话，用zs，用引用来访问这个对象
在 class Airplane 本身类中想访问 那4个成员变量，直接用 就行(因为在同一个类中)
eg：width = 50;(没有前面的a1 和 new对象)
在其他类中 想访问class Airplane类中的 属性 / 方法：
① 先 new 对象
② 通过引用a1 去打 .访问 .读的
Airplane a1 = new Airplane();
a1.width = 50; //给 成员变量(属性) 赋值了
a1.height = 45;
a1.x = 100;
a1.y = 200;
a1.step(); //调方法(若 有返回值要接收，有参数要传参)
a1.hitBullet();
a1.hitHero();
Airplane a2 = new Airplane(); //一个类可以创建多个对象
a2.width = 60;
a2.height = 55;
a2.x = 200;
a2.y = 345;
a2.step();
a2.hitBullet();
a2.hitHero();
class Airplane{ //小敌机类
int width;
int height;
int x;
int y;
void step(){ //小敌机移动
}
void hitBullet(){ //和子弹撞
}
void hitHero(){ //和英雄机撞
}
}
-----------------------------------------------------
package oo.day01;
//学生类
public class Student {
//成员变量 属性
String name; //首字母大写的都是类 String ， String是Java提供好的
int age; //只要是类都是引用类型，默认值为null
String address;
//方法 行为
void study(){
System.out.println(name+"在学习...");
}
void sayHi(){
System.out.println("大家好，我叫"+name+",今年"+age+"岁了，家住"+address);
}
}
package oo.day01;
//学生类的测试类 想访问学生类中的 成员变量(属性) 方法
public class StudentTest {
public static void main(String[] args) {
//创建了一个学生对象
Student zs = new Student();
//给成员变量赋值
zs.name = "zhangsan";
zs.age = 30;
zs.address = "陕西西安";
//调用方法
zs.study();
zs.sayHi();
Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "黑龙江佳木斯";
ls.study();
ls.sayHi();
//1)创建了一个学生对象 2)给成员变量赋默认值 3)调用构造方法
Student ww = new Student();
ww.study(); //没有赋值直接调，没报错，显示 null在学习... 引用类型默认值为null
ww.sayHi();
注意 默认值：
byte,short,int,long,char-----------------0
float,double-----------------------------0.0
boolean----------------------------------false
引用类型---------------------------------null
}
}
第二天：
1.方法的签名： 方法名+参数列表
Java规定：在同一类中，不能出现签名相同的方法
正确： 因为 是两个不同的类
class Aoo{
void show(){
}
class Boo{
void show(){
}
}
错误：
class Aoo{
void show(){
}
void show(){
}
}
Aoo o = new Aoo();
o.show(); //不知道 调哪个show，所以 会报错
错误： 虽然有 返回值，但是 签名 只看 方法名+参数列表
class Aoo{
void show(){
}
int show(){
return 1;
}
}
正确： 方法名 相同，参数不同，这个即就是 方法的重载
class Aoo{
void show(){
}
void show(String name){
}
}
class Aoo{ //这个 不叫方法的重载，因为不在同一类中
void show(){
}
class Boo{
void show(String name){
}
}
2.方法的重载(overload)：-------------便于用户的访问
1)发生在同一类中，方法名相同，参数列表不同 ，方法体不同
(方法体相同的话，就没有必要 写两个方法了)
2)编译器在编译时会根据 方法的签名 自动绑定调用的方法
2）举例：
class Aoo{
void show(){
}
void show(String name){
}
}
Aoo o = new Aoo();
o.show(); //自动调用 show() 无参的方法
o.show("zhangsan"); //自动调用 shou(String name) 有参的方法
------------------------------------------------------------------
package oo.day02; //正常情况下，每个类放在不同文件中，这里是方便展示
//重载的演示
public class OverloadDemo {
public static void main(String[] args) {
Aoo o = new Aoo(); //在这个类里 想访问Aoo类中 的东西，先new个对象
o.show();
o.show("zhangsan");
o.show(25);
o.show("zhangsan",25);
o.show(25,"zhangsan");
}
}
class Aoo{
void show(){}
void show(String name){}
void show(int age){}
void show(String name,int age){}
void show(int age,String name){}
//int show(){ return 1; } //编译错误，重载与返回值类型无关
//void show(String address){} //编译错误，重载与参数名称无关
}
3.构造方法： -------复用给成员变量赋初始值代码
1)给成员变量赋初始值 ------------作用是什么
2)与类同名，没有返回值类型(连void都没有) ------------怎么写
3)在创建(new)对象时会自动调用 构造方法 ------------怎么用
4)若自己不写构造方法，则编译器默认提供一个无参的构造方法，
若自己写了构造方法，则不再默认提供
5)构造方法可以重载
class Student {
String name;
int age;
String address;
//构造一个学生zs (需要下面4句话)
Student zs = new Student(); //new一个zs对象，此时，成员变量默认值是 null 0 null
zs.name = "zhangsan";
zs.age = 23;
zs.address = Xian";
//构造一个学生ls (也是需要下面4句话)
Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "JMS";
//因为new对象不能省，导致下面的3句话每次都重复，所以要用构造方法(一句话 减少重复)，给成员变量赋初始值
------------------------------------------------------------------
class Student {
String name;
int age;
String address;
//普通方法 void sayHi(){};
Student(){ //(无参 构造方法)
}
Student(String name1,int age1,String address1){ //构造方法(有参)，给成员变量赋初始值
name = name1;
age = age1;
address = address1;
}
}
调构造方法：
Student zs = new Student(“zhangsan”,25,“xian”);//1)创建了一个学生对象
2)给成员变量赋默认值
3)自动调用Student的有参构造方法
Student ls = new Student(“lisi”,26,“JMS”);
Student zs = new Student(); //1) 2) 3)自动调用Student的无参构造方法 (重载了)
5）的举例：
4.this： 指代当前对象，哪个对象调用方法 它指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认都有this.
eg：下面的 System.out.println(this.name+“在学习…”);
this：前两句话的举例：
class Student {
String name;
int age;
String address;
void study() { // zs.name(this的第一句话)
System.out.println(this.name+"在学习...");
}
void sayHi() { // zs.name // zs.age // zs.address
System.out.println("大家好，我叫"+this.name+"，今年"+this.age+"岁了，家住"+this.address);
}
}
public class StudentTest {
public static void main(String[] args) {
Student zs = new Student();
zs.name = "zhangsan";
zs.study();
zs.sayHi();
Student ls = new Student();
ls.name = "lisi";
ls.study();
ls.sayHi();
}
}
zs.study();-------------study()中的this指的就是zs
ls.study();-------------study()中的this指的就是ls
ww.study();-------------study()中的this指的就是ww
this的用法：
1) this. 成员变量名-----------访问成员变量
注意：当成员变量与局部变量同名时，若想访问成员变量则 this. 不能省略
2) this. 方法名()-------------调用方法(一般不用)
3) this()--------------------调用构造方法(应用率低)
this用法的举例：
Java规定:
1) 成员变量和局部变量是可以同名的
—1.1) 用的时候默认采取的是就近原则
—1.2) 若想访问成员变量，则this不能省略
2)结论：当成员变量与局部变量同名时，若想访问成员变量则 this. 不能省略
class Student {
String name; // 成员变量(作用范围:整个类)
int age;
String address;
// 构造方法 (目的是给成员变量赋值)
Student(String name,int age,String address){ //局部变量(作用范围:仅在当前方法中)
this.name = name; //zs.name=zhangsan 前面是成员，后面是局部
this.age = age; //zs.age=25 (this后面跟的是成员变量)
this.address = address; //zs.addrss=LF
}
void study(){
System.out.println(name+"在学习..."); //这的name前的this.可以省，因为它只认成员变量
}
void sayHi(){
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
}
}
public class StudentTest {
public static void main(String[] args) {
//Student zs = new Student(); //编译错误，Student中没有无参构造
Student zs = new Student("zhangsan",25,"LF");
zs.sayHi();
zs.study();
Student ls = new Student("lisi",26,"JMS");
ls.sayHi();
ls.study();
}
}
5.null 和 NullPointerException：
null：表示空，没有指向任何对象
若引用的值为null，则该引用不能再进行任何点操作了，
若操作则发生NullPointerException空指针异常
过程：a.y=200 先找a，就找到了地址，基于地址，找到了对象，找到后 把y从 0 改为200
a是引用类型，a=null，给a赋值为null，null表示为空，就啥也没有了，就没有地址了，即 没有指向任何对象
a.y=250 a赋值为null之后 再写a.y=250，语法没错，但不合理，因为 找a，a中什么也没有，即 也找不到对象，也找不到y。 所以 运行时会发生 NullPointerException空指针异常(指针就是地址)
创建对象时(只要一new)，引用类型的成员变量默认值为null（String 首字母大写了，是个类，是引用类型）
Student zs = null;
String name = null;
Airplane a = null;
内存管理： 内存由JVM来管理的 （分3为块区域）
1)堆： new出来的对象(包括成员变量)
2)栈： 局部变量(包括方法的参数)
3)方法区： .class字节码文件(包括静态变量、方法)
内存图：
只要是在方法中的 都叫局部变量，main方法也是，所以a1是局部变量，a1是引用类型变量（简称 引用）
栈中 a1是引用类型，里面装的是地址 (就是这个对象的地址)， a是基本类型，里面装具体的数
注意：是引用类型a1里装的是地址，不是栈 中装的是地址
引用类型 过程： 一new对象，分配对象到堆中 和 把它所有的成员变量都装到堆中， a1是局部变量 存在栈中， a1.x=100; ，找到a1，通过地址找到Airplane对象，把x从0改为100
基本类型过程： int a=5; 因为没new，所以堆中没有东西，栈中有a ，因为a是局部变量，a里面装的是 5 ，a=8，直接找到a，把5改为8
6. 引用类型之间画等号：
1)指向同一个对象
2)通过一个引用对数据的修改会影响另一个引用对数据的访问
eg:房子钥匙
之前是基本类型之间画等号：
1)赋值
2)对一个变量的修改不会影响另一个变量
eg：身份证复印件
eg：交换a和b的值：int a=5,b=8; int t=a;(等号两边都是基本类型int) …
1180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
