内容:
应用:对象和类
理解:面向对象程序设计
理解:方法的重载
掌握:构造方法
一、 面向对象
1.定义
首先根据用户需求抽象出业务逻辑对象
然后对需求进行合理的分层
构建对应的独立的业务模块
之后进行设计业务逻辑,利用封装,继承, 多态,抽象的思想
实现实际业务需求
最后通过整合各个模块,达到高内聚低耦合的效果,从而满足客户的需求。
面向对象是一种更符合我们思想习惯的的思想(懒人思想,我把自己的事情不做,交给别人去做)可以将复杂的事情简单化(对使用者来说简单了,但是对象里面是复杂的)
将我们从执行者变成了指挥者角色发生了转换。
二、 抽象数据类型:
所谓抽象数据类型可以理解为 将不同类型的数据的集合组成一个整体整体可以用来面熟一种新事物。
代码实现:
package cn.tedu.day05;
public void person(){
System.out.println("---------------");
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("性别:"+gender);
System.out.println("成绩:"+action);
}
}
public class Objective {
public static void main(String[] args){
String name="某某某";
int age=10;
char gender='女';
double score=98.00;
printStudent(name,age,gender,score);
printStudent("nema",15,'男',95.00);
Student stu1=new Student();
stu1.name="小泽";
stu1.age=15;
stu1.gender='女';
stu1.score=62.58;
printStudent(stu1.name,stu1.age,stu1.gender,stu1.score);
Student stu2=new Student();
stu2.printStudent(stu2.name, stu2.age, stu2.gender, stu2.score);
printStudent(stu2);
}
public static void printStudent(String name,int age,char gender,double score){
System.out.println("---------------");
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("性别:"+gender);
System.out.println("成绩:"+score);
}
public static void printStudent(Student stu){
System.out.println("---------------");
System.out.println("姓名:"+stu.name);
System.out.println("年龄:"+stu.age);
System.out.println("性别:"+stu.gender);
System.out.println("成绩:"+stu.score);
}
}
package cn.tedu.day05;
public class Student {
//姓名
String name="姜姜姜";
//年龄
int age=3;
//性别
char gender='女';
//成绩
double score=300;
public static void printStudent(String name,int age,char gender,double score){
}
}
运行结果:
三、类
类定义了一种抽象数据结构
类不但定义了抽象数据结构的组成(成员变量),同时还定义了可以对该类型实施的操作(方法)
类与对象
类的定义包括 “成员变量”的定义和“方法”的定义,其中“成员变量”用于描述该类型对象共同的数据结构。
JAVA语言中,类的成员变量的定义可以使用如下语法;
Class类名{
成员变量类型 变量名称:
……………
}
成员变量的类型 默认初始值
数值类型(byte,short,int,long,float,double) 0
boolean型 false
/u0000
char型
引用类型 null
类中除了定义成员变量,还可以定义方法,用于描述对象的行为,封装对象的功能。
JAVA语言中。可以按照如下方式定义类中的方法:
Class类名{
修饰词 返回值类型 方法名[参数列表]{
方法体………………
}
……………
}
代码实现:
package cn.tedu.day05;
public class Phone {
//品牌
String brand;
//价格
double price;
//颜色
char color;
//干嘛
String method;
public void phone(){
System.out.println("---------------");
System.out.println("品牌:"+brand);
System.out.println("价格:"+price);
System.out.println("颜色:"+color);
System.out.println("方法:"+method);}
public void thing (String name,Phone p){
System.out.println("用"+p.price+"的"+p.brand+"手机"+p.method);
System.out.println("打电话给"+name);
}
}
package cn.tedu.day05;
public class PhoneTest {
public static void main(String[] args){
Phone i=new Phone();
i.brand="ipXR";
i.price=6000;
i.color='黑';
i.method="发短信";
i.phone();
Phone p=new Phone();
p.brand="华为nova3";
p.price=3000;
p.color='蓝';
p.method="找对象";
p.phone();
String name="他";
p.thing(name,p);
Phone o=new Phone();
o.brand="小米note9";
o.price=3000;
o.color='红';
o.method="玩游戏";
o.phone();
}
}
运行结果:
四、局部变量和成员变量
1.定义位置:成员变量定义在类中,局部变量定义在方法中
2.作用域;成员变量作用在整个类中,局部变量作用在定义的方法中或者语句中使用
局部变量只能作用在定义他的方法或者语句中使用
3.内存中,成员变量存储在堆内存中,并且在堆内存中自动赋予初始值,局部变量存储在栈内存中,不会自动赋值.
4.生命周期:成员变量在对象创建的时候存储在堆内存中,
在对象被回收的时候被销毁,局部变量在方法或者语句中执行时候被创建,方法或者语句执行完毕后被销毁。
代码实现:
public class ZUOYONG {
public static void main(String[] args){
int x=5;
{
x=6;
int y=7;
System.out.println(x);
System.out.println(y);
}
System.out.println(x);
}
}
运行结果:
五、方法的重载
方法的签名包含如下两个方面:方法名和参数列表
一个类中,不可以有两个方法的的签名完全相同,即一个类中不可以有两个方法名和参数列表都完全一样。
如果一个类中的两个方法只是方法相同而参数列表不同,是可以的。
代码实现:
public class Chongzai {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a=5;
int b=3;
double c=25.00;
double d=10.00;
add(a,b);
System.out.print("\n=============\n");
add(c,d);
}
public static void add(int a,int b){
System.out.print(a+b);
}
public static void add(double a,double b){
System.out.print(a*b);
}
}
运行结果:
六、构造方法
构造方法是类中定义的方法,不同于其他的方法,构造方法的定义有如下两点规则:
构造方法的名称必须和类名相同
构造方法没有返回值
语法:
【访问修饰符】类名(){
//构造方法体
}
代码实现;
package cn.tedu.day05;
/*构造方法
*
*/
public class StudentA {
String name;
int age;
String address;
//构造方法
public StudentA(){
System.out.println("这是一个构造方法");
}
//构造方法的重载
public StudentA(String name){
this.name =name;
}
public StudentA(int age){
this.age=age;
}
public StudentA(String name,int age,String address){
this.name=name;
this.age=age;
this.address=address;
System.out.println("这又是一个构造方法");
}
//成员方法
public void printInFo(){
System.out.println("----------");
System.out.println("姓名"+name);
System.out.println("年龄"+age);
System.out.println("地址"+address);
}
}
package cn.tedu.day05;
/**
* 测试构造方法
* @author Administrator
*
*/
public class Test04 {
public static void main(String[] args){
StudentA s=new StudentA();
s.name="三";
s.age=20;
s.address="paris";
s.printInFo();
System.out.println("---------------");
StudentA s1=new StudentA("小王");
System.out.println(s1.name);
System.out.println("---------------");
StudentA s2=new StudentA("老王",20,"上海");
System.out.println(s2.name+s2.age+s2.address);
}
}
运行结果:
七、this关键字
this关键字用在方法体中,用于指向调用该方法的当前对象,简单地说,哪个对象调用方法,this指的就是那个对象,严格的来讲,在方法中需要通过this关键字指明当前对象
Public void drop(){
This.row++;
}
为了方便起见,在没有歧义的情况下可以省略this:
public void drop(){
row++;
}
八、继承
发现一些类中的属性和方法是相同的,所以把这些相同的属性和方法提取到一个新的类中,然后利用extends关键字让原来的类和新的类产生联系,这种联系称之为继承。
九、Extends关键字
-
通过extends关键字可以实现类的继承,
-
子类(sub class)可以继承父类(super class)的成员变量。同时也可以定义自己的成员变量和成员方法
-
Java语言不支持多重继承,一个类只能继承一个父类,但一个父类可以有多个子类。
代码实现:package cn.tedu.day05; public class Game { /** * 设计一个抽象类:父类 * @author Administrator * */ String name; //游戏名称 double version;//版本号 String agent; //代理商 public Game(String name,double version,String agent){ this.name=name; this.version=version; this.agent=agent; } public void start(){ System.out.println("游戏启动!"); } public void pause(){ System.out.println("游戏暂停!"); } public void close(){ System.out.println("游戏关闭!"); } public void print(){ System.out.println("游戏名称:"+name); System.out.println("版本号:"+version); System.out.println("代理商:"+agent); } } package cn.tedu.day05; /*LOL游戏 * 成员变量: * 游戏名称 * 版本号 * 代理商 * 成员方法: * 打开游戏 * 暂停游戏 * 关闭游戏 * 输出信息 * */ public class LOL extends Game { //游戏角色 String gameRole; public LOL(String name,double version,String agent,String gameRole){ super(name,version,agent); this.gameRole=gameRole; } public void print(){ super.print(); System.out.println("新增游戏角色:"+gameRole); } } package cn.tedu.day05; public class Dota extends PCGame{ public Dota(String name,double version,String agent){ super(name,version,agent); } } package cn.tedu.day05; public class GameTest { public static void main(String[] args){ LOL l=new LOL("lol",6.73,"Android","蛮王"); l.print(); l.start(); l.pause(); l.close(); Dota dota=new Dota("王者荣耀",9.51,"苹果"); dota.print(); dota.start(); dota.pause(); dota.close(); System.out.println("-------------"); Dota d=new Dota("开心消消乐",9.21,"腾讯"); d.print(); d.update(); d.start(); d.pause(); d.close(); } } package cn.tedu.day05; public class PCGame extends Game{ public PCGame(String name, double version, String agent) { super(name, version, agent); // TODO Auto-generated constructor stub } /*游戏更新*/ public void update(){ System.out.println("游戏更新!!!!"); } }
运行结果:
十、重写和重载
1.重载和重写是完全不同的语法现象,区别如下:
重载是指在一个类中定义多个方法名相同但参数列表不同的方法,在编译时,根据参数的个数和类型来决定绑定哪个方法。
重写是指在子类中定义和父类完全相同的方法,在程序运行时,根据对象的类型不同(而不是引用类型)而调用不同的版本。
2.重载遵循所谓“编译期绑定”,即在编译时根据参数变量的类型判断应该调用哪个方法,因为:变量obj的类型为Super,因此:Goo的g(Super)方法被调用,
重写遵循所谓的“运行期绑定”,即在运行时根据引用变量指向的实际对象类型调用方法,因为:obj实际指向的是子类的对象,因此:子类重写后的f方法被调用。
十一、封装:
对外提供的可调用的,稳定的功能
封装容易变化的。具体的实现细节,外界不可访问,这样的意义在于:
降低代码出错的可能性,便于维护;
当内部的实现细节改变时,只要保证对外的功能定义不变,其他的模块就不会因此受到牵连。