------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
一、面向对象概述
当需求单一,或者简单时,我们一步一步去操作没问题,并且效率也挺高。可随着需求的更改,功能的增多,发现需要面对每
一步骤很麻烦了,这时就开始思索,能不能把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的
封装在一起。这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。
例1-1:洗衣服问题
1).面向过程:
准备一盆水和洗衣粉-->将衣服放入盆->.反复搓洗干净->拿出晾。
2).面向对象:
找到洗衣机->衣服放进洗衣机->拿出晾干。
面向过程思想关注解决问题的具体步骤,即解决这个问题程序员需要做什么;
面向对象思想关注哪些对象能用于解决这个问题,如果有就调用这个对象,没有就按需求创建这个对象。
1、面向对象的特点
(1)封装(encapsulation)
将对象的属性和行为进行封装,其载体为类,类中的东西不需要被使用的人知道,也就是对用户隐藏内部细节,只需要对外提供使用就可以,这就是封装的思想。
封装原则:
将不需要对外提供的内容都隐藏起来。
把属性都隐藏,对外提供访问方法。
函数就是Java语言中最小的封装体。封装的好处:提高安全性、提高重用性、将变化隔离、便于使用
private:私有权限修饰符,用于修饰类中成员;私有内容只在本类中有效。
注意:私有仅仅是封装的一种表现形式。
(2)继承(inheritance)
类与类之间有关系,多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。通过extends关键字可以实现类与类的继承,class 子类名 extends 父类名 {} ,单独的这个类称为父类,基类或者超类;这多个类可以称为子类或者派生类。有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员
二、类和对象
1、类和对象概述
类:是一组相关的属性和行为的集合
对象:是该类事物的具体体现
例1-2:
对象:就是那个事物的实体.--实
class Phone
{//手机类
//价格
private int price;
//牌子
private String pingPai;
//系统
String os;
//颜色
String color;
//大小
double daXiao;
//像素
int xiangShu;
public void setPrice(int price){
<span style="white-space:pre"> </span> this.price=price;
}
public int getPrice(){
return price;
}
public void setPingPai(String pingPai){
<span style="white-space:pre"> </span> this.pingPai=pingPai;
}
public String getPingPai(){
return pingPai;
}
//打电话
public void call(){
System.out.println("打电话~~~");
}
//玩游戏
public void playGame(){
System.out.println("打游戏");
}
//发信息
public void sendMessage(){
System.out.println("发短信");
}
//玩app
public void app(){
System.out.println("下载app");
}
class PhoneTest
{
public static void main(String[] args)
{
//创建对象
Phone p =new Phone();//手机对象
//赋值
int price=2400;
if(price>0)
{
p.setPrice(price);
}
String brank="小米";
<span style="white-space:pre"> </span> p.setPingPai(brank);
p.os="安卓";
p.color="白色";
p.daXiao=5.0;
p.xiangShu=800;
System.out.println("我的手机:价格"+p.getPrice()+" 品牌"+p.getPingPai()+" 系统是"+p.os
+" 颜色"+p.color+" 大小"+p.daXiao+" 像素"+p.xiangShu+"万");
//调用方法
p.call();
p.playGame();
p.sendMessage();
p.app();
}
}
2、成员变量和局部变量的区别
成员变量 类中方法外
局部变量 方法内或者方法声明上
b:在内存中的位置不同
局部变量 栈内存
c:生命周期不同
成员变量 随着对象的存在而存在,随着对象的消失而消失
局部变量 随着方法的调用而存在,随着方法的调用完毕而消失
d:初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值,必须先定义,赋值,才能使用。
匿名对象两种使用情况
a:当对对象方法仅进行一次调用的时。
b:匿名对象可以作为实际参数进行传递。
例: new Car();
注:如果对一个对象进行多个成员调用,必须给这个对象起个名字。
三、封装
1、封装的概述:
是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
隐藏实现细节,提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则:
将不需要对外提供的内容都隐藏起来。把属性隐藏,提供公共方法对其访问。
2、private关键字
可以修饰成员(成员变量和成员方法)
private最常见的应用:
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
记住:
方法被哪个对象调用,this就代表那个对象
给对象的数据进行初始化
(2)构造方法格式
方法名与类名相同
没有返回值类型,连void都没有
没有具体的返回值
(3)构造方法注意事项
如果你不提供构造方法,系统会给出默认构造方法
如果你提供了构造方法,系统将不再提供
构造方法也是可以重载的
方法具体划分:
a:根据返回值
有明确返回值方法
返回void类型的方法
b:根据形式参数
无参方法
带参方法
6、类的标准的代码写法
成员变量
构造方法
无参构造方法
带参构造方法
成员方法
getXxx()
setXxx()
给成员变量赋值的方式
无参构造方法+setXxx()
带参构造方法
b:在栈内存为s开辟空间
c:在堆内存为学生对象开辟空间
d:对学生对象的成员变量进行默认初始化
e:对学生对象的成员变量进行显示初始化
f:通过构造方法对学生对象的成员变量赋值
g:学生对象初始化完毕,把对象地址赋值给s变量
(1)static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用
(2)static关键字注意事项
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法
静态变量属于类,所以也称为为类变量
成员变量属于对象,所以也称为实例变量(对象变量)
(2)内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
(3)内存出现时间不同
静态变量随着类的加载而加载,随着类的消失而消失
成员变量随着对象的创建而存在,随着对象的消失而消失
(4)调用不同
静态变量可以通过类名调用,也可以通过对象调用
成员变量只能通过对象名调用
在Java中,使用{}括起来的代码被称为代码块,根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)。
a:局部代码块
在方法中出现;限定变量生命周期,及早释放,提高内存利用率
b:构造代码块
在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行
c:静态代码块 在类中方法外出现,加了static修饰
在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且值执行一次。
12、类与对象练习
例3-1
class MyMathTest{
public static void main(String[] args){
MyMath mm = new MyMath();//创建对象
System.out.println(mm.add(5,8));
System.out.println(mm.sub(5,8));
System.out.println(mm.mul(5,8));
System.out.println(mm.div(5,8));
System.out.println(mm.div(5.0,8.0));
System.out.println("-----------");
//使用匿名对象
System.out.println(new MyMath().add(5,8));
System.out.println(new MyMath().sub(5,8));
}
}
class MyMath{
//构造方法
//无参 默认的
//有参 无
//成员方法
//特有方法
public int add(int a,int b){
return a + b;
}
public int sub(int a,int b){
return a - b;
}
public int mul(int a,int b){
return a * b;
}
public int div(int a,int b){
return a / b;
}
public double div(double a,double b){
return a / b;
}
}
例3-2
class GodnessTest{
public static void main(String[] args){
//创建女神对象
Godness g = new Godness("weibo",19,"女生");
g.show();
Godness g2 = new Godness("gaoqi",22,"女孩");
g2.show();
Godness g3 = new Godness("lingjian",20);
g3.show();
Godness g4 = new Godness("gaoqi",22,"女孩");
g4.show();
g4.sleep();
System.out.println("------------------");
//static方法调用方法,类名.方法名()
Godness.sleep();
Godness.sex;
g.show();
System.out.println(g.sex);
}
}
class Godness {
//成员变量
String name ;
int age;
//构造方法
//无参
Godness(){}
//有参
Godness (String name, int age,String sex ){
this.name = name;
this.age = age;
this.sex = sex;
}
Godness (String name, int age ){
this.name = name;
this.age = age;
}
//成员方法
//get /set
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
//特有方法
//吃饭
public void eat(String food){
System.out.println(this.name +"爱吃" + food);
}
//唱歌
public void sing(){
System.out.println(this.name +"爱唱歌");
}
static String sex;
static String country;
//自我介绍
public void show(){
System.out.println(name +"--"+age +"--" +sex);
}
public static void sleep(){
//System.out.println(name + "洗洗睡了~~~"); //错误: 无法从静态上下文中引用非静态 变量 name
System.out.println(sex + "洗洗睡了~~~");
}
}