zoukankan      html  css  js  c++  java
  • 移动打车项目1

    // 只能用一个类名 和文件名一致
    // 模块export andri
    //定义一个类  在外界调用
    public class HelloJava
    { // 主方法
     public static void main(String args[])
     {
      System.out.printIn("Hello java")
     }

    }
    return shell 开启一个线程  执行a.out return 的返回值 返回给shell
    calss Dog
    {
     Dog(){
     this.color = "black"
     }
     Dog(String color){
      this.color = color
     }
    public void sleep(){
     System.out.println(this.color + "Dog is sleep");
    }
    private String color;
    }

    public class Text2_demo
    {
     public static void main(String args[]){
     Dog dog1 = new Dog();
     Dog dog2 = new Dog("dahuang");
     dog1.sleep();
     }
    }

    值传递  c/c++  值传递  开辟新空间
    java python 基本类型传递的都是值传递, 复杂类型 引用
    byte,long double ,boolean, char , 解释方式不同
    应用类型: new 出来的都是引用
     
    class test3{
     // 共用的  静态  常量   类型
     public static final String content = "AC"
    }
    public class Text3
    {
     public static void main(String args[]){
      System.out.println(test3.content);
      test3 t = new test3();
      System.out.println(t.content);
      t.content = "123";
      System.out.println(t.content);
     }
    }
    public class Test4_static{
     
     private int a = 0;
     public static void main(String args[]){
     }
    }

    c/c++ : 类中的声明变量
    java: 中可以声明定义
    静态方法没有this指针;
    default: 在当前文件可用
    final  常量
    对有符号的不能左移。
    instanof
    公共类

    class Hero{
     public void attack(){
      System.out.println("attack");
     }
    }
    继承
    class Yase extends Hero{
     // 方法重写
     public void attack(){
      System.out.println("")
     }
    }
    public class Test_externts()
    {
         public static doAttack(Hero hero){
          if (hero instanceof Yase){
           System.out.println("yes");
          }esle if(hero instanceof Libai)
          {
           System.out.println("LIBAI");
          }
          hero.attack();// 多态
         }
         public static void main(String args[]){
          Hero hero = new Hero();
          hero.attack();
          Hero y = new Yase();
          y.attack();
          Hero l = new LiBai();
          l.attack();
     
         }
    }
    静态方法: 类方法

    public class Test_Array{
     public static void printArray(int[] array){
      for(int item: array){
       System.out.println(item);
      }
     }
     //  二维数组
     public static void printArray2(int..arry)
     {
      for(int i; i< array.length;i++)
      {
       System.out.println(array[i])
      }

     }
     
     public static void main(String args[]){
      int[] array1 = {1,2,3,4,5};// 定义一个数组
      int[] array2 = new int[5]; // 引用
     }
    }
      数组名值常指针

      组合方式:
      class Son1
      {
       Son1(Fathor fa)
       {
        this->fa = fa;
       }
       private:
        Fathor *fa;
      }
      继承方式:
      class Son: public Fathor
      {
      }
    导入包  
      import java.util.Date;
      public class Test_date{
       public static void main(String args){
        Date date = new Date();
        System.out.println(date.toString());
       }
      }
     时间:  系统时间
     localtime: 本地时间
     格式化时间:

     import java.util.*
     public class Test7{
      public static void main(String args[]){
       try{
        System.out.println(new Date()+" ");
        Thread.sleep(1000*3);
        System.out.println(new Date()+" ");
       }catch(Exception e){
        System.out.println("Gat an exception");
       }
      }
     }
    -----------------------------------------------
    //  默认继承 object
    class Hero{
     
     Hero(String name){
      this.name = name;
     }
     //  不能修改权限
     protected void finalize(){
     }
     private String name;
    }
    //  不定时回收
     public class Test7{
      public static void main(String args[]){
       Hero h = new Hero("Gailun");
    // 显示调用回收
      h = null;
      //手动执行
      System.gc();
      }
     }
     -------------------------------
     public class Test7{
      public static void main(String args[]){
       char[]  strArray = {"A","B","C"};
       String str1 = new String(strArray);
       String str2 = new String("abc");
       String str3 = "xye";
       String str4;
       str4 = String.format("%f,%d,%s",3.14,100,"itcast")
       System.out.println(str4);
      }
     }
     ----------------------------
     import java.io.*
     public class Test{
      
      public static void main(String[] args){
       byte[] binary = {1,2,3,4,5};
       //  输出流  文件流  进程往外流
       try{
        OutputStream os =new FileOutputStream("test.txt");
       for(int i=0;i<binary.length; i++){
        os.write(binary[i]);
       }
       os.close();

       InputStream is = new FileInputStream("test.txt");
       int size = is.available();
       for(int i=0;i< size;i++){
        System.out.print(is.read()+",");
       }
       is.close();
       }catch(IOException e){
       System.out.println("io error");
       }
       
      }
     }
     hexdump: 查看二进制文件表示方式
     00000000(地址)  0201 0403 0005
     00000005 (地址)
    -------------------------------------
    抽象类
    class Animal{
     public void move(){
     System.out.print("")
     }
    }
    class Dog extends Animal{
     
     public void move(){
      super()
      super.move();  // 第一个父类
      System.out.print()
     }
    }
    主方法
    public class TestDog{
     public static void main(String[] args){
     }
    }

    有虚函数
    abstract class Animal{
     abstract void eat();
     String name;  //属性
    }
    class Dog extends Animal{
     Dog(String name){
      this.name = name;
     }
     System.out.print(this.name + "sleep");

    }
    class Test{
     public static void show(Animal animal){
      animal.eat();
      if(animal instanceof Dog){
       Dog d = (Dog)animal;
       d.eat();
      }else if(animal instanceof Cat){
       Cat c = (Cat)animal;
       c.eat();
      }
     }
     public static void main(String []args){
      Animal cat = new Cat("Tom");
      Animal dog = new Dog("Big");
      show(cat);
      show(dog);
     }
    }
    ---------------------------
    interface Fight{
     public void attack();
     public void skill();
    }
    interface Action{
     public void run();
     public void die();
    }
    abstract Hero{
     Hero(Sting name){
     this.name = name;
     }
     public abstrack void kill();
     private String name;
    }
    class Gailun extends Hero implement Fight,Action{
     Gailun(){
      super("gailun");
     }
     // 实现接口
     public void attack(){}
     public void skill(){}
     public void run(){}
     public void die(){}
     // 实现抽象方法
     public void kill(){
      this.run();
      this.attack();
      this.skill();
     }

    }
    ---------------------
    mkdir Animals
    Animal.java
    package animals; //当前模块
    接口
    public interface Animal{
     public void eat();
     public void sleep();
    }
    --------------------
    vsp Cat.java
    package animals;
    public class Cat implements Animal{
     public void eat()
     {
      System.out.print("hhh");
     }
    }

    wq:
    一个包: 一个抽象类,两个实体类
    -----------------------
    import animals.Animal;
    import animals.cat
    import animals.Dog
    public class Test{
     public static void main(String args[]){
      Animal dog = new Dog();
      Animal Cat = new Cat();
      
     }
    }
  • 相关阅读:
    ServletContext 类 EL表达式
    tomcat HttpServlet 的请求方式和域对象存储数据的两种方式
    最新的vue没有dev-server.js文件,如何进行后台数据模拟?
    小程序的全局变量 定义和使用
    vue 生命周期钩子函数
    slice方法可以将“类似数组的对象”变成真正的数组 (遇到时候再研究一次)
    JS中一个new到底做了哪些事情?
    关于JS中的call()方法和apply() 暂时只接触到call() 等接触到apply()再回头来看
    关于 prototype与__proto__ (用到的时候再看一次 加深理解)
    关于闭包最好最容易的理解 -- 很好很强大留作自用
  • 原文地址:https://www.cnblogs.com/countryboy666/p/11570269.html
Copyright © 2011-2022 走看看