第一天:
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) …