2017.8.7

最新推荐文章于 2024-06-19 22:59:27 发布
最新推荐文章于 2024-06-19 22:59:27 发布
阅读量305 收藏 1
点赞数
分类专栏： 笔记本推荐 文章标签： 笔记本-1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21198501/article/details/76855975
版权

面向对象

面向过程：

面向对象：
A:是一种更符合我们思考习惯
B：可以将复杂的事情简单化
c:将我们从执行者变为指挥者
案列:

面向过程：
买电脑：
了解电脑的信息–>电脑的基本需求–>找到电脑对应得参数–>去电脑城买–>付款–>回来

面向对象：
打电话（电脑城客服）—->上门登记信息–>（客服）送电脑。

万事万物皆对象

大象装冰箱：
A：打开冰箱
B：装进冰箱
C：关闭冰箱

面向过程（编写）：
public staic void main(String arg[]){
open();
intin();
close();
}
public void open()
{
systeam.out.println(“开门”)
}
public void open()
{
systeam.out.println(“装进去”)
}

public void close()
{
systeam.out.println(“关闭”)
}

面向对象实现：
clss 大象{
public void open()
{
systeam.out.println(“装进去”)
}
}

class 冰箱{
public void open()
{
systeam.out.println(“开门”)

public void close()
{
systeam.out.println(“关闭”)
}

}

面向对象三大特征：
封装：
继承：
多态：

我们为什么学习编程语言？
答：是为了模拟现实世界的事物，实现信息化。

事物：
属性：
行为

类：
成员变量，
成员方法，
定义一个类就是定义成员方法和成员变量

定义学生类：
class student{
String name;
int id;
ect();
}
public void ect()
{

}

封装的使用

封装：隐藏对外的实现细节，对外提供公共的访问方式。

在封装中尽量把成员变量用private修饰。提供对应的ges/set方法

this的使用：代表当前的类的使用。

class student{
private String name;
Private int age;
}
public void setName(String name)
{
this.name=name;
}
public String getName(){
return name;
}

public void setInt(int age)
{
this.age=age;
}
public int getInt(){
return age;
}

构造方法：

A:方法名和类名相同
B:没有返回值类型，连VOID都没有。
c:没有具体的返回值

public student（）{}；

构造方法的重载：
public student （string name）{

}
public student (int age){}
public student(int age,String name){}

总结：给成员变量赋值有两种方法：通过setxxx和构造方法。

类的组成：成员变量，成员方法，构造方法。

static的特点

1.随着内的加载而加载
2.既可以修饰成员变量，也可以修饰成员方法
3.优先于对象存在
4.被所以对象所共享
5.可以通过类名调用

注意事项：

1静态方法访问只能访问静态成员变量和静态成员方法，
2在静态中没有this关键字。

(5)静态变量和成员变量的区别

    A:所属不同
        静态变量：属于类，类变量
        成员变量：属于对象，对象变量，实例变量
    B:内存位置不同
        静态变量：方法区的静态区
        成员变量：堆内存
    C:生命周期不同
        静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
        成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
    D:调用不同
        静态变量：可以通过对象名调用，也可以通过类名调用
        成员变量：只能通过对象名调用

多态的理解和识记

什么叫多肽？
某一个事物在不同时刻表现出来的不同状态。及事物多种形态。
案列1：

猫是猫，
猫是动物。
动物 d=new 猫（）

案列2：

水（液态，固态，气态）温度不同变化也不同。

多肽的前提：

A:要有集成
B:要有方法重写
c:要有父类引用指向子类对象
父 F=new 子（）；

案列3:

class Fu{
public void show(){
    Systeam.out.println("show zi");
    }
}
class zi extends Fu{
public void show(){
    Systeam.out.println("show zi");
    }
}
class dome{
public static void main(String []args){
    Fu f=new zi();
    }
}

编译看左边，运行看左边。

多肽的好处

A：提高了代码的维护性
B：提高了代码的拓展性

案列 猫狗案列：

public class  Animal{

public void cet(){
    systeam.out.println("ect);
    }

public void sleep(){
    systeam.out.println("sleep);
    }

}
    }


class dog extends Animal{

public void cet(){
    systeam.out.println("dog 吃肉);
    }

public void sleep(){
    systeam.out.println("站着sleep);
    }

}

    }

class cat extends Animal{

public void cet(){
    systeam.out.println("cat 吃肉);
    }

public void sleep(){
    systeam.out.println("趴着leep);
    }

}

    }

多肽的弊端：
不能使用子类特有的功能。

抽象的概述

必须用abstract关键字修饰
抽象的特点：

1.抽象方法不能有主体。
2.抽象中不一定有方抽象法，但是有抽象方法的类必须定义为抽象类。
3.抽象不能实列化
4.抽象方法有构造方法，但是不能实列化

案列分析

/*
假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

分析：
    普通员工类
        成员变量：姓名、工号以及工资。
        成员方法：工作
    经理类：
        成员变量：姓名、工号以及工资，奖金属性
        成员方法：工作

实现：
    员工类：
    普通员工类：
    经理类：

//定义员工类

abstract class Employee {
//姓名、工号以及工资
private String name;
private String id;
private int salary;

public Employee() {}

public Employee(String name,String id,int salary) {
    this.name = name;
    this.id = id;
    this.salary = salary;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public int getSalary() {
    return salary;
}

public void setSalary(int salary) {
    this.salary = salary;
}

//工作
public abstract void work();
}

//普通员工类

class Programmer extends Employee {

public Programmer(){}

public Programmer(String name,String id,int salary) {
    super(name,id,salary);
}

public void work() {
    System.out.println("按照需求写代码");
}
}

//经理类

class Manager extends Employee {
//奖金
private int money; //bonus 奖金

public Manager(){}

public Manager(String name,String id,int salary,int money) {
    super(name,id,salary);
    this.money = money;
}

public void work() {
    System.out.println("跟客户谈需求");
}

public int getMoney() {
    return money;
}

public void setMoney(int money) {
    this.money = money;
}

}

class AbstractTest4

 {
public static void main(String[] args) {
    //测试普通员工
    Employee emp = new Programmer();
    emp.setName("林青霞");
    emp.setId("czbk001");
    emp.setSalary(18000);
    System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
    emp.work();
    System.out.println("-------------");

    emp = new Programmer("林青霞","czbk001",18000);
    System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
    emp.work();
    System.out.println("-------------");

    /*
    emp = new Manager();
    emp.setName("刘意");
    emp.setId("czbk002");
    emp.setSalary(8000);
    emp.setMoney(2000);
    */
    //由于子类有特有的内容，所以我们用子类来测试
    Manager m = new Manager();
    m.setName("刘意");
    m.setId("czbk002");
    m.setSalary(8000);
    m.setMoney(2000);
    System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
    m.work();
    System.out.println("-------------");

    //通过构造方法赋值
    m = new Manager("刘意","czbk002",8000,2000);
    System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
    m.work();
}
}

接口的概述

接口的特点：

1.用interface来修饰
2.类实现接口用implement表示
3.接口不能列化

1.类与类：只能单继承，可以多层继承
2.类与接口：可以单实现，也可以多实现，
3.接口与接口：继承，也可以多继承，

抽象类与接口的区别

A:成员区别
        抽象类：
        接口：
    B:关系区别:
        类与类：
        类与接口：
        接口与接口：
    C:设计理念不同
        抽象类：is a，抽象类中定义的是共性功能。
        接口：like a，接口中定义的是扩展功能。

案列

*
猫狗案例,加入跳高的额外功能

分析：从具体到抽象
    猫：
        姓名,年龄
        吃饭，睡觉
    狗：
        姓名,年龄
        吃饭，睡觉

    由于有共性功能，所以，我们抽取出一个父类：
    动物：
        姓名,年龄
        吃饭();
        睡觉(){}

    猫：继承自动物
    狗：继承自动物

    跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
    接口：
        跳高

    部分猫：实现跳高
    部分狗：实现跳高
实现；
    从抽象到具体

使用：
    使用具体类

//定义跳高接口

interface Jumpping {
//跳高功能
public abstract void jump();
}

//定义抽象类

abstract class Animal {
//姓名
private String name;
//年龄
private int age;

public Animal() {}

public Animal(String name,int age) {
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

//吃饭();
public abstract void eat();

//睡觉(){}
public void sleep() {
    System.out.println("睡觉觉了");
}

}

//具体猫类

class Cat extends Animal {
public Cat(){}

public Cat(String name,int age) {
    super(name,age);
}

public void eat() {
    System.out.println("猫吃鱼");
}
}

//具体狗类

class Dog extends Animal {
public Dog(){}

public Dog(String name,int age) {
    super(name,age);
}

public void eat() {
    System.out.println("狗吃肉");
}
}

//有跳高功能的猫

class JumpCat extends Cat implements Jumpping {
public JumpCat() {}

public JumpCat(String name,int age) {
    super(name,age);
}

public void jump() {
    System.out.println("跳高猫");
}
}

//有跳高功能的狗

class JumpDog extends Dog implements Jumpping {
public JumpDog() {}

public JumpDog(String name,int age) {
    super(name,age);
}

public void jump() {
    System.out.println("跳高狗");
}
}

class InterfaceTest {
public static void main(String[] args) {
    //定义跳高猫并测试
    JumpCat jc = new JumpCat();
    jc.setName("哆啦A梦");
    jc.setAge(3);
    System.out.println(jc.getName()+"---"+jc.getAge());
    jc.eat();
    jc.sleep();
    jc.jump();
    System.out.println("-----------------");

    JumpCat jc2 = new JumpCat("加菲猫",2);
    System.out.println(jc2.getName()+"---"+jc2.getAge());
    jc2.eat();
    jc2.sleep();
    jc2.jump();

    //定义跳高狗并进行测试的事情自己完成。
}
}
迷茫_小白
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2017.9.10-9.12
bbbblzy的博客
09-12 281
图论的学习 图论是数组结构中非常重要的一块 学习了图论之后 我渐渐的告别了模拟和简单的算法 开始学习更高深的东西 以下是我觉得这两天学习中的重点： （1）邻接矩阵的读入： Int const maxn=100 Int a[maxn][maxn] memset(a,0, sizeof(a)); Cin>>n; For (int i=0;i
2018.12.28
weixin_43185011的博客
12-28 1745
关于细胞分化轨迹学习小笔记相关学习文章一、学习框架1.降维 相关学习文章 链接1: Reversed graph embedding resolves complex single-cell trajectories–2017（ 《Nature Methods》被引量40）. 链接2: Reconstruction of complex single-cell trajectories using...
员工类案例演示
LeoZuosj的博客
02-04 355
员工类案例演示 class Test2_Employee{ public static void main(String[] args){ Employee ee = new Employee("令狐冲", "10001", 30000); ee.work(); } } /* * A:案例演示 * 需求:定义一个员工类Employee
抽象类与抽象方法的练习:编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 对于Manager类来说，他既是员工，还
YingxueSec
02-20 7314
编写一个Employee类，声明为抽象类， 包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。 请使用继承的思想，设计CommonEmployee类和Manager类，要求类 中提供必要的方法进行属性访问 代码实现: /* 编写一个Employee类，声明为抽象类， 包含如下三个属性：name，id，salary。 提供必要的构造器和抽象方法：work()。 */ abstract class
JAVA每日作业day6.19
最新发布
2201_75555400的博客
06-19 1887
从题目可以得知，我们要定义两个类，一个项目经理类和程序员类并封装了起来，我们还定义了两个方法，方便使用这题我们用的是有参方法，1，创建项目经理类的对象，并赋值，然后使用work（）方法。2，程序员类也是如此。3，输出。
定义一个 Employee 雇员类，要求如下：(1) 属性有：id、name、salary(2) 运算符重载+：实现两个对象相加时，默认返回他们的薪水和
qq_26004719的博客
05-07 2244
class Employee: __init_flag=True def __init__(self,id,name,salary): self.id=id self.name=name self.salary=salary def __add__(self, other): if isinstance(other,Employee): return self.salary + othe...
【Java学习】自定义类（以Employee类为例）
melon_sama的博客
11-16 474
直接上代码~ Main： import java.time.*; public class Main { public static void main(String[] args){ Employee[] staff=new Employee[3]; staff[0]=new Employee("Alice",10000,1987,12,15); staff[1]=new Employee("Bob",20000,1983,11,12);
Java面向对象编程
Kanteroa的博客
11-29 503
Java面向对象编程实验03
VIVADO 2017.4 license 亲测可用
05-20
8. **更好的流程自动化**：通过改进的 Tcl 命令行界面和工作流管理，使得设计过程更加自动化和高效。 压缩包中的“vivado2017+IP.lic”文件是VIVADO 2017.4的许可证文件，用于激活软件并解锁特定功能。用户需要将这...
2014-2017.12高清日语N2日语2级考试真题及答案+解析+MP3听力原文（8套合集）.zip
08-25
2014-2017.12高清日语N2日语2级考试真题及答案+解析+MP3听力原文（8套合集） n2 2014.12真题.pdf n2 2014.12解析+听力原文+答案.pdf n2 2014.7真题.pdf n2 2014.7解析+听力原文+答案.pdf n2 2015.12真题.pdf n2 2015...
2017.8.4叮当配.rp
10-24
2017.8.4叮当配.rp
2017.8.5马庙小学课程开设情况调研报告.doc
09-29
2017.8.5马庙小学课程开设情况调研报告.doc
阿里智能营销平台商业产品手册(2017.8).pdf
06-29
阿里智能营销平台商业产品手册(2017.8).pdf
java基础（6）- 面向对象（3）
KeepLearning的博客
12-04 311
6.1abstract抽象类 6.2接口 6.3问题总结；值传参，对象作为参数时的值传参
抽象类
weixin_34050005的博客
03-20 115
1.1 抽象类概述当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具体实现方式，那么这些方法都有具体的方法体。但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。比如一个图形类应该有一个求周长的方法，但是不同的图形求周长的算法不一样。那该怎么办呢？分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相...
分析以下需求并实现 1.项目经理类Manager 属性：（姓名name、工号id、工资salary、奖金bonus）行为：工作work() 2.程序员类Coder
whyszan的博客
03-13 2126
System.out.println("工号为" + id + "基本工资为" + salary + "奖金为" + bonus + "的项目经理正在努力的做着管理工作，分配任务，检查员工提交上来的代码......");System.out.println("工号为" + id + "基本工资为" + salary + "的程序员正在努力的写着代码......");//setter和getter方法。//setter和getter方法。//setter方法赋值。//seteer调用。
抽象类练习员工案例
LeoZuosj的博客
07-29 904
抽象类练习员工案例 class Test03_Employee { public static void main(String[] args) { Coder c = new Coder("德玛西亚","007",8000); c.work(); Manager m = new Manager("苍老师","9527",3000,200...
【Java基础】测试项目经理类和程序员类
关于我转生变成程序猿这档事
12-13 3399
分析以下需求，并用代码实现： 1.定义项目经理类 属性： 姓名 工号 工资 奖金 行为： 工作work 2.定义程序员类 属性： 姓名 工号 工资 行为： 工作work 要求: 向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法 编写测试类: 完成这两个类的测试 分析: 项目经理类:姓名,...
vivado2017.4license
06-28
对于 Vivado 2017.4 版本的许可证获取，您可以按照以下步骤进行操作： 1. 打开 Xilinx 官网，并登录您的账户。 2. 进入“License”页面。 3. 选择“Vivado Design Suite”作为产品，并选择“2017.4”版本。 4. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值