面向对象(java菜鸟的课堂笔记)

类:相同的东西放在一起

分为属性和动作;

把一组或多组事物相同的特性的描述==》类

属性和动作被称为成员:

//声明类的属性信息

public class **{

String name;

int age;

char sex;

}

//声明类的动作信息(要在属性信息里面)

public void eat(){

System.out.println("eating");

}

public void study(){

System.out.println("study");

}

public void playgame(){

System.out.println("playing");

}

类==》抽象化

类当中的个体才能进行实际的操作

抽象化过程

对象==》类

具象化过程

类==》对象

面向对象==面向具象化的类;

产生对象(主类中)

student student1 = new student();

给对象赋值(主类中)

student.name = "***";

构造器:

实例化的时候自己调用

构造器名字必须和类名一致,并且没有返回值;

static 静态的

类级别的属性 static int ***;

被static 修饰的方法叫静态方法 只能调用静态属性;

匿名对象 只能进行一次调用

this.代表当前类本身

java 对象也可以增删改查

调用方法可以调用自己 用来循环;

flage 开关;

public 公共的 共有

private 私有 仅自己访问

protected 子类和父类共有 外部禁止访问

extends 继承

将两个类共有的部分抽离出来 过程叫泛化

抽离出来的类叫父类 被抽离的类叫做子类

子类继承父类元素 使用 extends ;

从父类分到子类叫做特化;

所有类默认继承Object类;

一个类只能直接继承一个父类 ;

分为间接继承和直接继承 ;

间接继承继承父类的父类;

方法的复写 相当于扩展父类的成员;

有相同的属性时 显示子类的,父类将被覆盖;

除非声明调用父类;

先调用父类构造器,后调用子类构造器;

super()调用父类构造器,必须写在第一行;写在子类构造器里面;

instanceof (强转换时使用)判断是不是某个类;

复写规则:(子类)

一同两小一大

this ();调用在有参构造器中调用无参构造器 (必须写在第一行)

将其他类型转换成int;

如果有转换不了的报数字格式化异常

int ** = Integer.parseInt(***)

ArrayIndexOutofBoundsException

NumberFarmatException 数字格式化异常

异常捕获:

try{}catch(Exception e){}

String * = i+" ";转换成String型

饿汉模式

懒汉模式

final定义的变量变为常量;

下面做一个超市的管理系统:

import java.util.*;                          //调包
public class Main{                          //建一个主类
  static Scanner sc = new Scanner(System.in);
  static int i = 0;
  static Chaoshi[] shop = new Chaoshi[100];
  public static void main(String[] args){              //主入口
    menu();                           //调用菜单方法
  }
  public static void menu(){                    //定义一个菜单方法
    System.out.println("============================");
    System.out.println("》欢迎进入超市库存统计系统《");
    System.out.println("=》 请输入对应数字进行操作《");
    System.out.println("=======》 1,进货存储 《");
    System.out.println("=======》 2,修改信息 《");
    System.out.println("=======》 3,查询库存 《");
    System.out.println("=======》 4,退出操作系统 《");
    System.out.println("============================");
    int a = sc.nextInt();                      //用户输入
    switch (a){
      case 1:adds(); break;
      case 2:update(); break;
      case 3:select(); break;
      case 4:exit(); break;
      default:System.out.println("====输入有误,请重新输入====");
      menu();
      break;
    }
  }
  public static void adds(){                      //定义一个存货方法
    System.out.println("=========请输入货物名称=========");
    String sname = sc.next();
    System.out.println("=========请输入货物类型=========");
    String sclass = sc.next();
    System.out.println("=========请输入货物价格=========");
    String sprice = sc.next();
    System.out.println("=========请输入货物数量=========");
    String snum = sc.next();
    Chaoshi shop1 = new Chaoshi(sname,sclass,sprice,snum);
    shop[i] = shop1;
    i++;
    System.out.println("输入成功,继续输入(1),返回菜单(2)");
    int flage = sc.nextInt();
    if(flage==1){
      adds();
    }else menu();
  }
  public static void update(){                      //定义一个修改方法
    System.out.println("请输入商品名称,为您修改");
    String b = sc.next();
    for(i=0;i<100;i++){
      if(b.equals(shop[i].sname)){
        System.out.println("===================查询结果如下===================");
        shop[i].say();
        System.out.println("=========请输入修改后货物名称=========");
        String sname = sc.next();
        System.out.println("=========请输入修改后货物类型=========");
        String sclass = sc.next();
        System.out.println("=========请输入修改后货物价格=========");
        String sprice = sc.next();
        System.out.println("=========请输入修改后货物数量=========");
        String snum = sc.next();
        Chaoshi shop1 = new Chaoshi(sname,sclass,sprice,snum);
        shop[i] = shop1;
        System.out.println("继续修改(1),返回菜单(2)");
        int flage = sc.nextInt();
        if(flage==1){
          update();
        }else menu();
      }
    }
  }
  public static void select(){                      //定义一个查询方法
    System.out.println("指定查询(1),全部查询(2)");
    int a = sc.nextInt();
    if(a==1){
      System.out.println("请输入商品名称,为您查询");
      String b = sc.next();
      for(i=0;i<100;i++){
        if(b.equals(shop[i].sname)){
          System.out.println("===================查询结果如下===================");
          shop[i].say();
          System.out.println("继续查询(1),返回菜单(2)");
          int flage = sc.nextInt();
          if(flage==1){
            select();
          }else menu();
        }
      }
    }else{
      for(Chaoshi s:shop){
        if(s!=null){
        s.say();
        }
      }
      System.out.println("继续查询(1),返回菜单(2)");
      int flage = sc.nextInt();
       if(flage==1){
        select();
      }else menu();
    }
  }
  public static void exit(){                      //定义一个退出方法
  System.out.println("===》》》您已退出操作系统《《《===");
  System.exit(0);
  }
}

public class Chaoshi{                          //新建一个超市类
  String sname;
  String sclass;
  String sprice;
  String snum;
  public Chaoshi(String sname,String sclass,String sprice,String snum){
    this.sname = sname;
    this.sclass = sclass;
    this.sprice = sprice;
    this.snum = snum;
  }
  public void say(){
    System.out.println("名称:"+sname+"\n种类:"+sclass+"\n价格:"+sprice+"\n数量:"+snum+"\n");  //定义一个输出方式
  }
}

时间: 2024-11-02 13:07:09

面向对象(java菜鸟的课堂笔记)的相关文章

泛型(java菜鸟的课堂笔记)

1. 泛型的简单运 用和意义 2. 泛型的上限与下限 3. 泛型和 子类继承的限制 4. 泛型类和泛型 方法 5. 泛型嵌套和泛型擦除 泛型(Generic) 什 么是泛型: ?java5开始出现的 一种对Java语 言类型的 一种拓 展,以 支持创建可以按类型进 行 参数化的类.可以把类型参数看作是使 用参数类型时指定的类型占位符,就好 比 方法的形式参数是实际参数的占位符 一样. ?泛型能保证 大型应 用程序的类型安全和良好的维护性;使 用泛型的优势: ?类型安全,使编译器 对泛型定义的类型

C#面向对象编程基础-喜课堂笔记

**************[5][C#面向对象编程基础]第1讲:类与对象**************** ????????????????*************2.1.1_类与对象的概念************** ? 研究对象的入口是: 静态特征:-------属性(什么样子) 动态特征:-------方法!(能做什么)这两个也是对象区分的重要因素! 3. 对象表示世界中的实体,面向对象编程就是将这些实体模拟到计算机中! 4. 什么是封装? ????封装是指将一个或多个小对象包装在一起,

JAVA 韩老师课堂笔记-- 1-22讲

1. 抽象类和接口的区别: 抽象类是指不能被实例化的类,由abstract关键字修饰. 抽象方法是指没有方法体的方法,也就是一个空方法,是要被子类或扩展类来具体实现的方法. 接口是更抽象的抽象类,因为抽象类中允许存在非抽象方法(甚至可以一个抽象方法都没有),而接口中的所有方法均必须是抽象方法: 2. 集合框架(Linkedlist, Arraylist, HashSet, HashMap,): 优势:没有大小限制.

JAVA的面向对象编程--------课堂笔记

JAVA的面向对象编程--------课堂笔记 面向对象主要针对面向过程. 面向过程的基本单元是函数.   什么是对象:EVERYTHING IS OBJECT(万物皆对象)   所有的事物都有两个方面: 有什么(属性):用来描述对象. 能够做什么(方法):告诉外界对象有那些功能. 后者以前者为基础. 大的对象的属性也可以是一个对象.   为什么要使用面向对象: 首先,面向对象符合人类看待事物的一般规律. 对象的方法的实现细节是屏蔽的,只有对象方法的实现者了解细节. 方法的定义非常重要.方法有参

线程(java课堂笔记)

1.两种方式的差异 2.线程的生命周期 3.线程控制(线程的方法) 4.线程同步 5.线程同步锁 一. 两种方式的差异 A extends Thread :简单 不能再继承其他类了(Java单继承)同份资源不共享 B implements Runnable:( 推荐) )多个线程共享一个目标资源,适合多线程处理同一份资源. 该类还可以继承其他类,也可以实现其他接口. 二. 线程的生命周期 新建:当程序使用new创建一个线程后,该线程处于新建状态,此时他和其他java对象一样,仅仅由Java虚拟机

java/android 设计模式学习笔记(7)---装饰者模式

这篇将会介绍装饰者模式(Decorator Pattern),装饰者模式也称为包装模式(Wrapper Pattern),结构型模式之一,其使用一种对客户端透明的方式来动态的扩展对象的功能,同时它也是继承关系的一种替代方案之一,但比继承更加灵活.在现实生活中也可以看到很多装饰者模式的例子,或者可以大胆的说装饰者模式无处不在,就拿一件东西来说,可以给它披上无数层不一样的外壳,但是这件东西还是这件东西,外壳不过是用来扩展这个东西的功能而已,这就是装饰者模式,装饰者的这个角色也许各不相同但是被装饰的对

Android菜鸟的成长笔记(27)——SurfaceView的使用

前面有关自定义View中进行了绘图,但View的绘图机制存在如下缺陷: 1.View缺乏双缓冲机制. 2.当程序需要更新View上的图像时,程序必须重绘View上显示的整张图片. 3.新线程无法直接更新View组件. 由于View存在上面缺陷,所以在游戏开发中一般使用SurfaceView来进行绘制,SurfaceView一般会与SurfaceHolder结合使用,SurfaceHolder用于向与之关联的SurfaceView上绘图,调用SurfaceView的getHolder()方法即可获

java/android 设计模式学习笔记(12)---组合模式

这篇我们来介绍一下组合模式(Composite Pattern),它也称为部分整体模式(Part-Whole Pattern),结构型模式之一.组合模式比较简单,它将一组相似的对象看作一个对象处理,并根据一个树状结构来组合对象,然后提供一个统一的方法去访问相应的对象,以此忽略掉对象与对象集合之间的差别.这个最典型的例子就是数据结构中的树了,如果一个节点有子节点,那么它就是枝干节点,如果没有子节点,那么它就是叶子节点,那么怎么把枝干节点和叶子节点统一当作一种对象处理呢?这就需要用到组合模式了. 转

Android菜鸟的成长笔记(27)——ViewPager的使用

ViewPager是Android 3.0以上可以使用的API. 一.ViewPager能干什么? 1.微信5.0中连带滑动用ViewPager可以轻松实现. 2.实现类似于新浪微博的导航引导界面. 3.实现其他导航或菜单. 二.ViewPager的使用 1.添加布局 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_pa