面相对象三大特征-类与对象

复习

编程思想

面向过程
思想:
    只考虑事物的发展顺序

面向对象
思想:
    先考虑事物中存在哪些对象,再建立对象与对象之间的关系

对象的概念

生活中
    真实存在的事物
代码中
    万事万物皆对象(具有指向性)

类的概念

本质:就是概念或模版(只是方便创建对象的工具罢了)
    多个对象抽取共同点形成的概念即为类

类与对象的关系

一个类中可以有多个对象,多个对象可以属于同一个类
​
生活中:先有对象,后有类(类是从多个对象中抽取共同点形成的概念)
代码中:先有类,后有对象

类的定义与组成

定义

语法
    访问权限修饰符 class类名{
    
    }

组成

属性

作用:
    描述事物的静态特征,如人的身高,姓名,性别,年龄等
​
位置:
    类中方法外
​
别名:
    成员变量,局部变量
​
注意事项:
    属性有默认值,基本数据类型默认为0,引用数据类型默认为null
    
成员变量与局部变量的区别:
    成员变量
        位置:类中方法外
        默认值:有
        作用域:当前类中皆可
        生命周期:随着对象创建而生成,随着对象销毁而销毁
    局部变量
        位置:方法中
        默认值:无
        作用域:当前方法
        生命周期:随着方法生成而生成,随着方法执行完而销毁

方法

作用:
    描述事物的动态特征,如吃饭,喝水,打游戏等
    
位置:
    类中方法外
​
别名:
    函数
​
注意:
    一个类汇总不能出现两个或两个以上,方法名相同,形参列表也相同的方法
    
特殊情况:
    重载:
        在同一个类中,方法名相同,形参列表不同的方法

构造函数

作用:
    创建该类对象
    
位置:
    类中方法外
​
语法:
    访问权限修饰符 构造函数名(形参列表){
        方法体
    }
​
注意:
    1.构造函数没有返回值,也没有返回值类型
    2.使用new关键字
    3.构造函数名必须与类名一致☆
    4.一个类中没有构造函数,系统会自动提供一个无参构造函数.如果有则不提供
    5.一个类中可以有多个构造函数
    6.不能形成递归

对象的创建与使用

创建

语法:
    数据类型 对象名 = new 构造函数(实参列表);
​
此行代码做了哪些操作
    1.使用new关键字在堆内存中开辟一片运行空间
    2.给属性赋初值
    3.执行构造函数中的代码
    4.将堆中的地址,赋值给栈中引用

使用

操作属性

获取属性值
    语法
        对象名.属性名
​
修改属性值
    语法
        对象名.属性名 = 值;

调用方法

语法
    对象名.方法名(实参列表);

this

概念:
    谁调用this所在的方法,this就代表谁

场景1
	当局部变量与属性名重名时,用于区分

class A{
    private String name;//属性名为name
    public A(String name){//形参name,也是局部变量
        this.name = name;
        //就近原则后面的name在方法中,离方法最近,所以代表的是形参name
        //重名时this代表的是属性name
    }
}

场景2
	当在本类中使用本类的属性或方法时,默认使用this调用
	此时this可以忽略不写

class A{
    private String name;
 name = "aaa";
 //此时就忽略了this   this.name
 public void eat(){}
 public void eatTest(){
     eat();
     //此时也是忽略了this  this.eat()
 }
}

场景3
    在本类构造函数中调用本类其他构造函数
    语法
        this(实参列表);

class A{
    private String name;
    //无参构造
    public A(){}
    //全参构造
    public A(String name){
        //调用无参构造,如果调用的是有参的就在()里加上参数
        this();
    }
​
}

注意:
    必须在构造函数第一行

---

今日

面相对象三大特征

封装

概念:
	包装一段代码

优点:
	1.方便使用
	2.保护内部
	3.降低耦合度
	4.提高复用率

具体体现
	变量:
		封装着一个值或内存地址
	方法:
		封装着一段代码
	类:
		封装着属性,方法,构造函数
	...
	java中的封装无处不在

包
    本质:
        就是一个src下的文件夹
    
    作用:
        对java文件进行分类存储,使其便于寻找
    
    创建:
        选择src
        点击鼠标右键
        点击new
        选择package
        填写包名
        
    包名:
        命名规则:全小写
        潜规则:
            com.公司名称缩写或项目名称.分类名称
        
    注意:
        .代表下一级文件

导包
    作用:
        在当前java文件中使用其他文件夹下的类,此时需要导包
        
    语法:
        import 包名.类名;
        
    位置:
        类上
    
    关键字:
        import
        importjava.util.*;
        表示导入java.util下的所有类

访问权限修饰符

作用:
    限制其修饰的内容的使用范围

关键字				中文名				范围
public				公共的				当前项目中
protected			受保护的			当前包下或继承关系中
不写					默认的				当前包下
private				私有的				当前类下

经验
	属性使用private修饰
	方法使用public修饰
	
	1.只要写类,就直接编写无参构造和全参构造
	2.私有化所有属性
	3.提供公共的get和set方法,(get获取属性,set修改属性值)

继承

概念
	生活中:晚辈继承长辈遗留下的精神或物质遗产
	代码中:多个类抽取共同点形成类,此时该类与这几个类就可以有继承关系

优点
    子类将拥有父类所有的属性和方法(构造函数除外)
    提高复用率

语法
    访问权限修饰符 class 子类名 extends 父类名{}

注意
    1.一个类只能有一个父类(单继承)
    2.而一个父类可以有多个子类
    3.子类构造函数中默认调用父类的无参构造函数
    
    4.子类构造函数中必须调用父类的构造函数☆
    
    object是所有类的父类,如果一个没有明确的父类,默认继承object
    
    父类的别名:基类,根类
    
    开闭原则:
        对修改关闭
        对扩展打开

重写

在继承关系中
子类中方法与父类的方法,方法名相同,形参列表也相同
子类该方法的访问权限修饰符不能小于父类的
子类该方法的返回值类型与父类一致

super

含义:
	谁调用super所在的方法,super就表示谁的父类对象

场景1
	当子类重写父类方法后,在子类中使用super区分,是子类重写的方法还是父类提供的方法
	
super.方法名(实参列表)		父类提供的方法
方法名(实参列表)			子类重写后的方法

场景2
	当子类属性名与父类属性名重名时,使用super区分

super.属性名		父类属性
属性名				子类属性

public class Test {     //环境类
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}
class Fu{       //父类
    public String text =  "父";
    public void method(){
        System.out.println("父类方法");
    }
}
class Zi extends Fu{        //子类
    public String text = "子";
    public Zi(){        //子类无参构造
        this("xxx");
    }
    public Zi(String text){//子类有参构造
​
    }
    public void method(){   //子类重写父类方法
​
        System.out.println("子类方法");
        //谁调用super所在的方法,super就表示谁的父类对象
        super.method();     //子类调用super,super就表示为"Zi"的父类"Fu"的方法
        System.out.println(super.text);//同上,父类的text
        System.out.println(text);//就近text,子类的
    }
}
​

多态

概念:
    一个事物的多种形态

物的多态

子类对象转换为父类对象
    自动转换
    语法
        父类名 对象名 = 子类对象;
​
父类对象转换为子类对象
    强制转换
    语法
        子类名 对象名= (子类名)父类对象;
    
    有分险
    有分险
    有分险

class Fu{}
class Zi{}
class Test{
    public static void main(String[] aaa){
        Zi zi = new Zi();
        //子类对象转换为父类对象
        //自动转换
        Fu fu = zi;
        
        Zi zi = (Zi)fu;//父类对象转换子类对象
    }
}

instanceof

作用:
    判断该对象是否属于该类
注意:
    判断的对象与类之间要存在关系
语法:
    对象名 instanceof 类名
    最后得出个boolean值,可以用变量接收
    boolean 变量名 = 对象名 instanceof 类名;
    如果为true,表示对象属于该类
    如果为false,表示对象不属于该类
    如果IDEA提示此行代码有问题,则对象与类无关系

事的多态

重载
    要求:在同一个类中,方法名相同,形成列表不同
重写
    要求:同上分重写
​
注意:
    当子类对象转换为父类对象后,调用重写的方法,依旧执行的是子类重写后的方法,毕竟本质上还是子类.

---

作业

1,整理笔记
​
2,面向对象基础）根据注释，把下面代码补充完整  
//定义一个Dog 类
class Dog{
//定义一个name 属性，该属性为String 类型
______________________;
//定义一个age 属性，该属性为int 类型
______________________;
//定义一个sexual 属性，该属性为boolean 类型
//true 表示为公，false 表示为母
______________________;
public Dog(){}
    public Dog(String name, int age, boolean sexual){
    //分别根据参数，设置Dog 类的属性
    }
    public void play(){
        System.out.println(name + "play");
    }
    public void play(int n){
        System.out.println(name + "play" + n + "minutes");
    } 
}
public class TestDog{
public static void main(String args[]){
Dog d;
//创建一个Dog 对象，利用带参数的构造函数
//名字为joy，年龄为2 岁，性别为母
_________________;
//调用Dog 对象无参的play 方法。
_________________;
//调用Dog 对象有参的play 方法，参数为30
_________________;
} 
}
​
3,面向对象基础）写一个Worker 类，并创建多个Worker 对象。
1) 为Worker 类添加三个属性，1）String 类型的name，表示工人的姓名；
2）int 类型的age，表示工人的年龄；3）double 类型的salary，表示工人
的工资。
3) 为Worker 类添加两个构造方法，1）公开无参构造方法；2）接受三个参
数的构造方法，三个参数分别为字符串、int 和double 类型。
4) 为Worker 类添加两个work 方法，一个无参，另一个带整数参数，表示
工人工作的时间（为多少小时）。Worker如下的属性的类型以及构造方法相关的参数
        name:String
        age:int
        salary:double
        Worker()
        Worker(name:String,age:int,salary:double)
        work();
        work(hours:int) 
​
        在测试类中进行测试 工人类
        
4,有如下代码
​
class Super{
​
  private void method(){}
​
  }
​
  class Sub extends Super{
  //1
  }
}
在//1 处，能编译通过的代码为：
​
A. public int method(){return 0;}
​
B. void method(){}
​
C. void method(int n){}
​
D. private void method(){}
​
5,什么是多态,子类对象转换为父类对象后,调用重写的方法会怎样?
​
6,设计一个台灯类(Lamp)其中台灯有灯泡类(Buble)这个属性，
还有开灯(on)这个方法。设计一个灯泡类(Buble)，
灯泡类有发亮的方法，其中有红灯泡类(RedBuble)和绿灯泡类(GreenBuble)
他们都继承灯泡类(Buble)一个发红光,一个发绿光
​
7,看程序，写运行结果
​
（继承、对象构造过程）有以下代码
class ClassA{
    public ClassA(){
        System.out.println("ClassA()");
    } 
}
class ClassB{
    public ClassB(){
        System.out.println("ClassB()");
    } 
}
class ClassC extends ClassA{
    public ClassC(){
        System.out.println("ClassC()");
    } 
}
class ClassD extends ClassB{
    private ClassA ca = new ClassA();
    private ClassC cc;
    public ClassD(){
        System.out.println("ClassD()");
    }
    public ClassD(int i){
        cc = new ClassC();
        System.out.println("ClassD(int)");
    } 
}
public class TestConstructors{
    public static void main(String args[]){
        ClassD cd1 = new ClassD();
        ClassD cd2 = new ClassD(10);
    } 
}
​
8,定义一个动物类，里面有一个方法voice(),
        定义一个类Cat,实现voice方法
        然后增加一种新的动物类型：Pig(猪)，实现voice()方法。
        定义一个Dog类，实现voice方法
        定义一个Store（宠物店）类的getInstance方法：
        如果传入的参数是字符串dog，则返回一个Dog对象；
        如果传入pig，则返回一个Pig对象；否则，返回一个Cat对象。
        
        提示：字符串进行判断 通过equals（字符串）方法 
        
9,定义榨汁机JuiceMachine 有榨汁方法makeJuice，传入相应的水果。
        如果传入的是Apple 输出   "流出苹果汁"
       传入的是Orange 输出  "流出橙汁"
       传入的是Banana 输出  "流出香蕉酱"
       
10,假如我们在开发一个系统时需要对员工类类进行设计，程序员是员工，包含3个属性：姓名、工号以及工资。
    经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
    请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。
    (将昨天的这道题,自己分析员工的功能,子类体现出方法重写,测试的时候使用多态方式进行测试)
    
11,什么是方法重写,什么是方法重载
​
12,附件题,小明宠物医院