• java拾笔-1


    数据类型:之类型转换

        char a='a';//a这个字符在ASCII编码上位于97位
        char b='中';
        
        int i=a;//自动类型转换
        char d=48;
        System.out.println(i);//97
        System.out.println(d);//0  这个0不是整形0 而是一个字符0
        int i2=b;
        System.out.print(i2);//'中'这个字符在ASCII编码上位于48位        

    在取值范围内,int转换为byte,short,char不需要强制转换,强制类型转换有时会损失精度

    byte,short,char之间相互转换需要转换为int进行过度

    i++,++i

            int i=5;
            int k=i++;
            System.out.println(k);//5
            System.out.println(i);//6
            
            int m=++i;
            System.out.println(m);//7
            System.out.println(i);//7            

     位运算&,|,^  建立在二进制数的运算

            System.out.print(1&2);//0
            System.out.print(1|2);//3
            System.out.print(1^2);//3

     java面向对象

      面向对象方法将世界看作一个个相互独立的对象,只有在某种外部力量的驱动下,对象之间才会依据某种规律相互传递信息。不像面向过程那样把世界看作是一个紧密关联的系统。一个车的后视镜坏了,面向过程是换整辆车,面向对象是换后视镜。

    Java中类和对象:

      对象保存在堆中

      对象的引用(用来保存对象在堆中的地址),保存在栈中

    private:

        public void setType(String _type){
          type=_type;
        }
        public String getType(){
            return type;
        }    
    computer.setType("inter i5");
    System.out.print(computer.getType());

     构造方法

      一种特殊的方法,是一个与类同名且没有返回值类型的方法。其功能主要完成对象的初始化,当类实例化一个对象时会自动调用构造方法,可以重载

      注意:1.构造方法是特殊的成员方法,与类同名,在对象实例化时由虚拟机自动调用

            2.没有返回类型,也不能有返回值

         3.每个对象在生成时都必须执行构造方法,并且只能执行一次

         4.如果构造方法调用失败,那么对象也无法创建

         5.在没有定义构造方法的情况下,类会自动产生一个无参数的默认构造方法,这个默认构造方法什么都不做

         6.一旦显式的定义了构造方法,默认构造方法自动消失

    static

    1.   只有在所有对象都是同一个属性值的时候我们才建议到属性上用static修饰
    2.   在static的方法或者语句块中不能使用this、super关键字
    3.   在static中不能使用非static的成员(属性、方法)
    4.   在非static中可以使用static的成员(属性和方法)也可以使用非static的成员
      public class Student {    
          String name;         //成员变量
          static int age;//18  //静态变量        
          public void eat(){   //成员方法        
              System.out.println(name);//
              System.out.println(age);//
              play();//
          }        
          public static void play(){  //静态方法
              //System.out.println(name);//不能
              System.out.println(age);////eat();//不能
          }        
      }

       * 1.不管创建多少个对象,静态代码块始终只执行一次,因为我们的类只加载一次
       * 2.静态代码块始终在成员代码块之前执行,因为他在类加载时就执行
       * 3.静态代码一般用来做一些全局的初始化操作

    //Super:
    public
    Dog(){ //super();如果不写,默认执行父类的无参构造 System.out.println("Dog类的无参构造"); } public Dog(String name){ this();//调用本类的无参构造 this.name=name; }
    1. 子类的构造方法中必须调用其父类的构造方法
    2. 如果未显示,则默认调用父类无参构造 如果显示,则super必须位于第一行
    3. 如果未显示而父类没有无参构造则程序报错(一般要写上无参构造,以防以后报错)

    final

      1.final修饰类,则该类不允许被继承

      2.final修饰方法,则该方法不允许被重写

      3.final修饰属,变量,一旦赋值将不可改变

    final关键字经常和static一起使用来定义一个常量,这时候我们一般将变量名大写

      final static int MONTH_NUM=12;

    Object类常用方法的使用:
    toString方法:toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂
    的信息表达式。建议所有子类都重写此方法

    Dog dog=new Dog();
    System.out.print(dog)//默认输出dog.toString(),输出dog的地址
    
    @Override
    public String toString(){
        return "想要输入的格式";//          
    }


    equals方法:Object类的equals方法默认比较的是对象的引用是否指向同一个内存地址,如果需要判断自
    定义类型对象内容是否相等,则需要重写equals方法(字符串重写了equals方法)
    ==:比较的是值是否相同如果相同返回true,否则返回false如果是引用数据类型变量比较的是地址值(地址
    值相等返回true,否则返回false)

    Person p1=new Person("宏彬",25);
    Person p2=new Person("宏彬",25);
    System.out.print(p1==p2);//false
    System.out.print(p1.equals(p2));//false    new开辟地址,p1,p2地址不相同
    
    @Override
    public boolean equals(Object obj){
       if(this==obj){
             retrun true;    
        }
         if(obj instanceof Person){
              Person p=(Person) obj;
              if(this.name.equals(p.name&&this.age==p.age){//根据需求写equals
                   return true;
                   }
              }      
              return false;
    }

     单例模式

    1.饿汉式:(缺点:占内存)

    //Human.java
    public class Human {
        static Human human=new Human();//对外提供一个可以可以得到当前类得对象的公共方法(返回值应该是当前类的类型)
        
        private Human(){
            
        }
        public static Human getHuman(){
            return human;
        }
    }
    //Test.java
    public class Test {
        public static void main(String[] args){
            Human h1=Human.getHuman();
            Human h2=Human.getHuman();
            System.out.println(h1);
            System.out.println(h2);
            System.out.print(h1.equals(h2));
        }
    }
    //
    se.Human@15db9742
    se.Human@15db9742
    true

    2.懒汉式

    //缺点:线程的同步
    public class Human {
        static Human human;
        private Human(){
            
        }
        public static Human getHuman(){
            if(human==null){
                human=new Human();
            }
            return human;
        }
    }

     抽象类

    //A.java
    //抽象类可以拥有抽象方法,也可以拥有不抽象的方法
    //抽象类可以没有抽象方法,但抽象方法必须出现在抽象类中,抽象方法和抽象类不能被final修饰
    public abstract class A {//抽象类
        public abstract void m1();//抽象方法
        public void m2(){
            System.out.print("m2的方法");
        }
    }
    //B.java
    public class B extends A{
        public static void main(String[] args){
            //A a=new A();Error  A是抽象的,无法被实例化
            B b=new B();
            b.m1();
        }
        @Override//一个非抽象类继承了抽象类,则必须将抽象类中的抽象方法重写
        public void m1() {//抽象类有构造方法,他的构造方法是给子类创建对象用的
            System.out.print("B的m1方法");
        }
    }

     interface

    /**
     * java中的接口
     * 1.接口也是一种引用类型
     * 2.定义:[修饰符] interface 接口名{}
     * 3.在接口中只能出现:常量,抽象方法  int a=1;等价于final static int a=1;  public void m1;默认加上了abstract
     * 4.接口没有构造方法,无法被实例化
     * 5.接口可以有子类,但不叫继承,而是叫实现,用关键字implements表示
     * 6.单继承,多实现    一个类可以同时实现多个接口
     * 7.但一个非抽象的类实现了某个接口,则必须重写该接口中所有的抽象方法
     * 8.一个类多实现的语法:       implements 接口1,接口2
     */
    public class InterfaceTest implements Interface01,C {
        
        public static void main(String [] args){
            
        }
    
        public void m10() {
            
        }
      @Override
        public void m2() {
            
        }
    }

     多态

    //DuotaiTest1.java:       
         Animal animal=new Animal(); Animal dog=new Dog();//向下转型 Dog a=(Dog) animal;//保证这个动物是Dog类。向上转型 Dog a=(Dog)new Animal()
    //DuotaiTest2.java
         Animal animal=new Bird();
            if(animal instanceof Dog){//2、判断animal是否是Dog类,用到instanceof关键字。向上转型
                Dog dog=(Dog) animal;
                System.out.print(dog);//1、Bird cannot be cast to faceObj4.Dog,animal是Bird类
            }
            else{
                System.out.print("不是狗");
            }
    //Master.java
    //    public void feed(Dog dog){
    ////        System.out.println("喂狗的方法");
    //    }
    //    public void feed(Bird bird){
    //        System.out.print("喂鸟的方法");
    //    }  
         public void feed(Animal a){ System.out.println("喂"+a+"的方法");
    //DuotaiTest3.java
    Master master=new Master();
    
    Dog dog=new Dog();
    Bird bird=new Bird();
    
    master.feed(dog); //Animal a=dog   多态//喂faceObj4.Dog@15db9742的方法
    master.feed(bird); //Animal a=bird//喂faceObj4.Bird@6d06d69c的方法
    //Animal.java
    public void move(){
            System.out.print("我是动物我能动");
        }
    //当子类全都重写了move类,父类中move类不能不写,由于Master.java中用了a.move,会报错move多态,找不到父类中move方法
    //用抽象解决
    //public abstract void move();
  • 相关阅读:
    洛谷 U140360 购物清单
    洛谷 U140359 批量处理
    洛谷 U140358 操作系统
    洛谷U140357 Seaway连续
    洛谷 U141394 智
    洛谷 U141387 金
    CF1327F AND Segments
    刷题心得—连续位运算题目的小技巧
    CF743C Vladik and fractions
    洛谷 P6327 区间加区间sin和
  • 原文地址:https://www.cnblogs.com/xin-zhizhu/p/13152834.html
Copyright © 2020-2023  润新知