一，1.面向过程
都是一步一步做,来解决问题.C
2.面向对象
基于面向过程,解决问题,找一个对象了完成,对象本身包含了过程.
3.举例:
洗袜子:
面向过程:拖了-->泡一泡-->扭一扭-->搓一搓-->漂洗-->晾干
找女朋友洗袜子:
面向对象:说两句好话.
煎饼果子:
面向过程:上网搜一下,哪家强?-->买家伙什儿-->买材料-->摊煎饼-->找个人试吃-->你就可以吃了
找摊煎饼大妈:
面向对象:嗯-->掏钱-->吃
找到那个对象 new
4.面向对象思想特点
是一种更符合我们思想习惯的思想--懒人的思想
可以将复杂的事情简单化
角色发生了转换,执行者-->指挥者
5.面向对象思想三大特征
1.封装
2.继承
3.多态
二，
A:我们学习计算机语言,那么计算机语言是干嘛的?
对现实世界的描述-->实现了信息化-->虚拟化
B:我们如何描述现实世界事物的呢?
属性: 脸 ,眼镜 ,腿 ,腰 -->天生的
功能: 爱旅游,爱音乐, 琴棋书画 -->后天的
手机:
属性:像素,大小,价格,形状,内存,品牌,型号 iPhone6s
功能:玩游戏,拍照,打电话,发信息,看电影,上网,
成员变量--> 属性
成员方法--> 功能
学生:
成员变量(属性):姓名,年龄,身高,性别,学号
成员方法(功能):学习,吃饭,睡觉,敲代码
C:Java中最基本描述事物的单位是类( 分类 ),Java中用class描述事物也是如此
class 分类,分门别类, 物以类聚
定义类就是描述一类事物
定义类 {
成员变量
成员方法
}
class Phone {
成员变量
像素,大小,价格,形状,内存,品牌,型号
成员方法
玩游戏,拍照,打电话,发信息,看电影,上网,
}
D:定义类其实就是定义类的成员(成员变量和成员方法)
举例: 分析:
学生类:
属性:姓名,年龄,身高,性别,学号
功能:学习,吃饭,睡觉,敲代码
实现:
class 学生{
成员变量:
姓名,年龄,身高,性别,学号
成员方法:
学习,吃饭,睡觉,敲代码
}
E:类和对象的概念
类:(定义类)--> 现实事物的描述--虚
对象:(创建对象)-->现实事物的实体--实
题外话:为什么叫面向对象,不是面向类呢?
真正使用的是对象
定义类 --> 创建对象--> 使用对象的方法
/*
继承的由来:
当很多类有重复的属性或者方法,那么我们就把重复的部分抽取出来,封装为一个类,让很多类来继承这个单独的类,重复的部分就不用写了.
继承的格式:
class B extends A{ }
class C extends A{ }
继承的特点:
1.单继承
2.多层继承 --构成了继承体系
如果描述这个体系,共性的属性或者功能,看顶层
如果使用这个体系的属性和功能,使用 最低层
继承的注意事项:
1.父类中private修饰的成员,子类不能使用.
private只能本类访问
2.父类中构造方法,子类不能使用
构造方法名字跟类名一致
3.不要为了部分的功能去继承
产品经理管程序员叫爹(不合适)
继承实现了类与类的关系
类中:
成员变量:
变量名字不同:父类有的子类可以直接用
变量名字相同:子类使用的时候自己的
子类还想使用父类的成员,怎么办? 使用super
super.成员 表示的是父类的成员
this 和super的区别:
this:当前对象的引用 (创建对象)
super:父类存储空间的标识 (理解为父类的引用)
局部变量 成员变量 父类成员变量 使用顺序?
局部变量:num =10;
成员变量: this.成员
父类成员: super.成员
就近原则去找
构造方法:不能继承,但是我们可以调用父类的构造方法
子类的构造方法默认调用 父类的无参构造.
因为构造方法是给类初始化数据的,子类如果想使用父类的成员变量的值,那么必须用父类的先构造初始化.
注意事项:
1.父类中的成员变量被private修饰了,还得对外提供一个公共的访问方式.构造方法就是public的,那么子类想构造,就可以直接调用父类的构造方法了!
2.父类中没有无参构造
方式一:使用super中的有参构造
方式二:使用this中的有参构造,前提是有参构造也得访问到父类super有参构造中
3. super和this 必须在第一行,并且只能有一个
成员方法 : 都是可以被继承的
get()/set()
show()/ call()
如果子类中写了跟父类同名的方法,子类方法覆盖父类方法,这叫方法重写.
重写和重载的区别:
重写:子类和父类,方法声明一模一样,子类覆盖父类方法
重载:本类中,方法名一样,参数列表不同
重写的应用:
子类可以增强父类的方法,通过 super.父类方法名增强.
关键字:
final:被final修饰的东西,不能被改变.
可以修饰类 变量 方法
*/
<pre class="java" name="code">/*
多态: 一种事物的多种形态
H2o
固态:冰,雪,霜,雹子
液态:水,雾,水蒸汽
气态:水蒸气
动物:
天上飞的:鸟
地上跑的:猫,狗
水里游的:鱼,海豚
1.满足继承关系
2.方法的重写.(如果不重写,就失去了多态的意义)
3.父类引用指向子类对象
成员变量
编译看左边,运行看左边.
成员方法
编译看左边,运行看右边
构造方法
编译看左边,运行看左边.
静态方法
编译看左边,运行看左边.
*/
class AnimalTest{
public static void main(String[] args){
Animal aa = new Animal();
Cat c = new Cat();
Animal a = new Cat(); //多态
a.sleep(); // 子类方法
System.out.println(a.leg);
a.eat();
}
}
class Animal {
//成员变量
int leg =4;
Animal(){}
public void sleep(){
System.out.println("晚上睡觉 ");
}
public static void eat(){
System.out.println("吃好吃的,饱饱的");
}
}
class Cat extends Animal{
//成员变量
int leg =3;
Cat(){}
//成员方法
public void sleep(){
System.out.println("白天想睡就睡");
}
public static void eat(){
System.out.println("吃鱼,不吐刺儿");
}
}
/*成员变量和局部变量的区别 类中的位置不同:成员变量: 类中方法外局部变量: 在方法中内存中的位置不同:成员变量: 堆内存中局部变量: 栈内存中数据的生命周期不同:成员变量: 随着对象的创建而出现,垃圾回收器回收才消失.局部变量: 随着方法的加载而出现,方法结束就消失了.初始值不同:成员变量:有初始化值,一般默认的.局部变量:没有初始化值的,必须使用前,给其赋值.注意事项:局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。*/class {public static void main(String[] args){System.out.println();}}
/*
1.我是把形参的参数名字,就换成了成员变量名字一致
2.成员变量的名字就无法赋值
3.把set方法成员变量前面 加 this.
this:当前对象
*/
class GodnessTest{
public static void main(String[] args){
//创建女神对象
Godness g = new Godness();
// g.name ="李嘉欣";
// g.age = 30;
// 调用setAge方法来给age属性赋值
// g.sanWei = "38,25,40";
// g.sex = "女";
g.setName("贾玲");
g.setSex("汉子");
g.setSanWei("100,100,100");
int a =30;
if (a > 0 && a < 100){
g.setAge(a);
}
System.out.println(g.getAge());
//调用成员方法
// g.show();
// g.say("采臣,小心掉水里");
g.say("女神和女汉子 ? ");
g.photo(9);
Godness g2 = new Godness();
g2.setName("冰冰");
}
}
//定义女神类
class Godness{
//成员变量
private String name;//名字
private int age;//年龄 使用 private 保护age属性
// GodnessTest.java:62: 错误: age可以在Godness中访问private
private String sanWei; //三围"10,10,10"
private String sex;//性别
int num =20;
//定义给age赋值的方法
public void setAge(int age){ //a 30;
this.age = age;
}
public int getAge(){
return age;
}
public void setName(String name){ //a 30;
this.name = name;
}
public String getName(){
return name;
}
public void setSanWei(String sanWei){ //a 30;
this.sanWei = sanWei;
}
public String getSanWei(){
return sanWei;
}
public void setSex(String sex){ //a 30;
this.sex = sex;
}
public String getSex(){
return sex;
}
//成员方法
//走红毯
public void show(){
System.out.println("女神"+name +"走红毯,年龄是" + age +",三围"+sanWei );
}
//名言
public void say(String words){
System.out.println( "女神" + name + "说:" + words );
}
//自拍
public void photo(int num){
num = 30;
System.out.println("自拍(局部)"+ num + "张");
System.out.println("自拍(成员)"+ this.num + "张");
}
}/*
继承的由来:
当很多类有重复的属性或者方法,那么我们就把重复的部分抽取出来,封装为一个类,让很多类来继承这个单独的类,重复的部分就不用写了.
继承的格式:
class B extends A{ }
class C extends A{ }
继承的特点:
1.单继承
2.多层继承 --构成了继承体系
如果描述这个体系,共性的属性或者功能,看顶层
如果使用这个体系的属性和功能,使用 最低层
继承的注意事项:
1.父类中private修饰的成员,子类不能使用.
private只能本类访问
2.父类中构造方法,子类不能使用
构造方法名字跟类名一致
3.不要为了部分的功能去继承
产品经理管程序员叫爹(不合适)
继承实现了类与类的关系
类中:
成员变量:
变量名字不同:父类有的子类可以直接用
变量名字相同:子类使用的时候自己的
子类还想使用父类的成员,怎么办? 使用super
super.成员 表示的是父类的成员
this 和super的区别:
this:当前对象的引用 (创建对象)
super:父类存储空间的标识 (理解为父类的引用)
局部变量 成员变量 父类成员变量 使用顺序?
局部变量:num =10;
成员变量: this.成员
父类成员: super.成员
就近原则去找
构造方法:不能继承,但是我们可以调用父类的构造方法
子类的构造方法默认调用 父类的无参构造.
因为构造方法是给类初始化数据的,子类如果想使用父类的成员变量的值,那么必须用父类的先构造初始化.
注意事项:
1.父类中的成员变量被private修饰了,还得对外提供一个公共的访问方式.构造方法就是public的,那么子类想构造,就可以直接调用父类的构造方法了!
2.父类中没有无参构造
方式一:使用super中的有参构造
方式二:使用this中的有参构造,前提是有参构造也得访问到父类super有参构造中
3. super和this 必须在第一行,并且只能有一个
成员方法 : 都是可以被继承的
get()/set()
show()/ call()
如果子类中写了跟父类同名的方法,子类方法覆盖父类方法,这叫方法重写.
重写和重载的区别:
重写:子类和父类,方法声明一模一样,子类覆盖父类方法
重载:本类中,方法名一样,参数列表不同
重写的应用:
子类可以增强父类的方法,通过 super.父类方法名增强.
关键字:
final:被final修饰的东西,不能被改变.
可以修饰类 变量 方法
*/
<pre class="java" name="code">/*
继承的特点:
单继承:一个类只能继承一个类
理解: 一个儿子只有一个亲爹
extends //认亲爹
多层继承:子类继承父类,父类继承爷爷类
理解:类似家谱
爷爷
|
|
父亲
|
|
儿子
问题:
1.使用对象的时候,创建谁?
创建子类,使用子类
2.寻找体系类的共性功能(属性方法),寻找谁?
看这个体系最顶层的类
如果你写的类什么都没有继承,默认继承一个类 Object类
*/
/*
注意事项:
1.父类私有的属性和方法,子类是无法继承的
理解:
皇上传皇位给皇子, 但是 皇后,皇妃不能传的,是皇上私有的private.
class {
private String name;
private int age;
private 账户;
public String getName(){
}
}
2.构造方法不能继承
构造方法名跟类名一致 ,子类和父类名字不一致
class Fu{
Fu(){}
}
class Zi extends Fu {
Zi(){}
}
3.不能随便继承, 也就是不能随便认亲爹.
不能因为想要一些功能,就继承
公司入职,你会敲代码, 产品经理并一定会敲,如果产品经理想回敲代码.
什么时候使用继承 ?
子类 is a 父类 这样的关系
西瓜 is a fruit
学生 is a person
西瓜 is a 苹果
*/
class {
public static void main(String[] args){
System.out.println();
}
}
class 动物 {
}
class 猿人 extends 动物{
}
class 猿 extends 猿人 {
}
class 人 extends 猿人{
}
class 猿 extends 人{
}
/*描述手机 定义手机类 class 手机 {成员变量 //牌子String brand;//型号 String type;//价格 int price;//颜色 String color;成员方法 //打电话public void call(){Syso(...);}//发信息 public void sendMsg(String text){Syso("发信息:" + text )}//玩apppublic void playApp(){Syso("玩app:" );}}*/class PhoneTest{public static void main(String[] args){//创建对象 Phone p = new Phone();//使用成员 //变量p.brand = "苹果";//型号 p.type ="5s";//价格 p.price=2999;//颜色 p.color = "土豪金";System.out.println("从前有一个手机,牌子是"+p.brand +",型号"+p.type+ ",并不贵 "+p.price +"颜色是"+ p.color+"要不?" );System.out.println("---------------------" );//方法 p.call();p.sendMsg("妈妈喊你回家吃饭,妈妈喊你回家吃饭,妈妈喊你回家吃饭");p.playApp();Phone p2 = new Phone();p2.brand = "诺基亚";//型号 p2.type ="n98";//价格 p2.price=3000;//颜色 p2.color = "黑色";System.out.println("从前有一个手机,牌子是"+p2.brand +",型号"+p2.type+ ",并不贵 "+p2.price +"颜色是"+ p2.color+"要不要?" );//方法 p2.call();p2.sendMsg("妈妈喊你回家吃饭,妈妈喊你回家吃饭,妈妈喊你回家吃饭");p2.playApp();Phone p3 = p;p3.brand = "小米";p3.type = "安卓机皇";p3.price = 2999;p3.color = "天然竹子";System.out.println("从前有一个手机,牌子是"+p.brand +",型号"+p.type+ ",并不贵 "+p.price +"颜色是"+ p.color+"要不?" );}}//定义手机类 --描述手机 class Phone {//成员变量//牌子String brand;//型号 String type;//价格 int price;//颜色 String color;//numint num = 20; //成员变量//成员方法 //打电话public void call(){int num = 10; //局部变量System.out.println("打电话" + num);}//发信息 public void sendMsg(String text){System.out.println("发信息:" + text );}//玩apppublic void playApp(){System.out.println("玩微信,玩陌陌,玩比邻");}}
1584
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
