Java的自学之旅08

最新推荐文章于 2024-11-03 11:01:20 发布

一逝鸿轩寂

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量205

点赞数 1

分类专栏：心路历程文章标签： java

本文链接：https://blog.csdn.net/weixin_40518706/article/details/120307191

版权

心路历程专栏收录该内容

56 篇文章 2 订阅

订阅专栏

一.对象类型转换（Casting）

1.基本类型数据类型的Casting：

自动类型转换[小的数据可自动转换成大的数据类型]fe:long g=20;double d=12.0f

强制转换类型[可以把大的数据类型强制转换（Casting）成小的数据类型]fe:float f=(float)12.0;int a =(int)1200L

2.对java对象的强制类型转换称为造型

（1）从子类到父类的类型转换可以自动进行

（2）从父类到子类的类型必须通过造型强制类型转换实现

（3）无继承关系的引用类型间的转换是非法的

在程序中的具体展现

public class Test {
    public static void main(String[] args) {
//        int i=10;
//        long l=i;
//       long l=10;
//       int i=(int) 1;
//        Student s=new Student();
//        person p=s;//从子类到父类的类型转换可以自动进行
//        Person p=new Person();
//        Student s=(Student) p;//从父类到子类的类型必须通过造型强制类型转换实现

//        Test t=new  Test();
//        Person p1=t;//无继承关系的引用类型间的转换是非法的
        //Object是所有类的最高类
//        String s= "hello";
//        Object obj=s;//从子类到父类的类型转换可以自动进行
//        System.out.println(obj);
        Object obj="hello";
        String s=(String)obj;//从父类到子类的类型必须通过造型强制类型转换实现
        System.out.println(s);
    }
}可以输出hello

下面进行一些相关的演练

Person父类写如下

public class Person {
    public void test(){
        System.out.println("这是Person的方法");
    }
}

Student子类写如下代码

public class Student extends Person {
    public void getSchool(){
        System.out.println("这是getSchool的get方法");

    }
}

        Test t=new  Test();
        t.method(new Person());
        t.method(new Student());
    }
    public void method( Person e){
        if (e instanceof Student){
            Student s= (Student) e;//alt+enter快捷键强制转换
            s.getSchool();
        }else {
            e.test();
        }
    }
}
输出

二.操作符与equa方法（==：）

1.基本类型比较值：只要两个变量的值相等，即为true。int a=5;if(a==6){...}

引用类型比较引用（是否指向同一个对象）：只有指向同一个对象时，==才返回true

Person p1=new Person();

Person p2=new Person();

if(p1 == p2){...}

用==进行比较时，符号两遍的数据类型必须兼容（可自动转换基本数据类型除外）否则出错。

使用方法如下展示

//        int i=3;
//        System.out.println(i==4);
        Person p1=new Person();
//        Person p2=new Person(); // fast
        Person p2=p1;// true
        System.out.println(p1==p2);
//        System.out.println(p1==t);//不能比较没有一点关系用==进行比较时，符号两遍的数据类型必须兼容（可自动转换基本数据类型除外）否则出错。
//
//

2.equals（）：所有类都继承了Object,也就获得了equals（）还可以重写，只能比较引用类型，其作用和==相同比较是否指向同一个对象

格式：obj1.equals（obj2）

特例：当用equals（）方法进行比较时，对类file string date及包装类（wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象：

结论：

（1）对特殊类file string date==比较对象的地址，equals比较内容

（2）普通的数据除特殊外两个方法都是比较的内存地址

（3）如果想改变一个类的equals，不想用equals来比较对象内存地址那就需要重写equals方法

原因：这些类中重写了Object类的equals（）方法.

程序中的比较：

        Person p1=new Person();
        Person p2=p1;// true
        System.out.println(p1==p2);//true
        System.out.println(p1.equals(p2));//true
         String s1=new  String("abc");
         String s2=new  String("abc");
         System.out.println(s1==s2);//false
         System.out.println(s1.equals(s2));//true

三.String对象的创建（字面量创建在常量池堆中不重复 String s1=abc; String s2=abc那就只有一个;，new创建先在堆中有没有没有就建一个（new出的常量计入堆中但不是常量会创建新的new对象相同的对象 String s1=new String("abc"); String s2=new String("abc");）这个时候就有两个对象abc）

练习（1）编写Order类，有int型的orderld,String的OrderName.相应的getter()和setter()方法，两个参数构造器，重写父类的equals()方法：public boolean equals(Object obj),并判断测试类中的两个对象是否相等。

编写Order类

public class Order {
    public  Order(int orderId,String OrderName){
        this.orderId=orderId;
        this.OrderName=OrderName;

    }
    int orderId;
    String OrderName;

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return OrderName;
    }

    public void setOrderName(String orderName) {
        OrderName = orderName;
    }

    @Override
    public boolean equals(Object obj) {
        boolean flag=false;
        if (obj instanceof Order){
            Order o=( Order) obj;
            if (this.orderId==o.orderId&&this.OrderName.equals(o.OrderName)){
                flag=true;
            }

        }
        return  flag;
    }
}

test

Order o1=new  Order(11124,"a00DWS1D");
Order o2=new  Order(124,"a004523");
System.out.println(o1.equals(o2));

Order o1=new  Order(124,"a001");
Order o2=new  Order(124,"a001");
System.out.println(o1.equals(o2));

(2)根据以下代码自行定义满足要求的MyDate类，在MyDate类中覆盖equals方法，使其判断当两个MyDate类型对象的年月日相同时，结果为true否则为false. public boolean equals(Object o),

MyDate类 
public class MyDate {
    public MyDate(int year,int month, int day){
        this.day=day;
        this.month=month;
        this.year=year;
    }
    int year;
    int month;
    int day;

    @Override
    public boolean equals(Object obj) {
        int flag=1;
        if (obj instanceof MyDate){
            MyDate md= (MyDate) obj;
             flag=0;if (this.year!=md.year){
                 flag+=1;
            }if(this.month!=md.month){
                flag+=1;
            }if(this.day!=md.day){
                flag+=1;
            }
        }if (flag==0){
            return true;
        }else { return false;

        }

    }
}

判断测试

MyDate m1=new MyDate(2020,9,15);
 MyDate m2=new MyDate(2020,9,15);
 System.out.println(m1.equals(m2));

MyDate m1=new MyDate(2030,9,15);
 MyDate m2=new MyDate(2020,9,15);
 System.out.println(m1.equals(m2));

四.包装类（Wrapper）

1.针对八种基本定义相对应的引用类型【boolean byte short int long char float double】包装类（封装类）与基本的对应【Boolean Byte Short Integer Long Character Float Double】

2.有了类的特点，就可以调用类中的方法

实例装箱

//装箱
//        Integer i= new Integer(111);
        Integer i= new Integer("111");
//        Integer i= new Integer("avc");//编译不错运行有错
        System.out.println(i);

//拆箱
        Integer i1= new Integer(112);
        int i0=i.intValue();
        System.out.println(i0);
        boolean b=new  Boolean("false").booleanValue();
        System.out.println(b);

Integer i2=111;//自动装箱

int i3=i2;//自动拆箱

3.(1)字符串转换成基本数据类型

通过包装类的构造器实现int i=new Integer("121");

通过包装类的 parseXxx(String s)静态方法：Float f=Float.parseFloat("12.1");

(2)基本数据类型转换成字符串

调用字符串重载的valueOf()方法：

String fstr =String.valueOf(2.24f);

直接的方式：String intStr=5+""

(3)tostring

MyDate m=new MyDate(123,455,454);
System.out.println(m.toString());//父类的object的toString输出当前对象的内存地址
System.out.println(m);//等价

在 MyDate里面重写以后

@Override
public String toString() {
    String str =this.year+"-"+this.month+"-"+this.day;
    return str;
}

测试

MyDate m=new MyDate(123,455,454);
System.out.println(m.toString());//父类的object的toString输出当前对象的内存地址
System.out.println(m);

输出

五.关键字static（静态的）

public class Chinese {
   static String country;//类变量不用实例化，直接类名.属性名就可用使用，是类的一部分，被所有类的实例化对象所共享
    String name;
    int age;//实例变量实例化之后才能使用，属于实例化的一部分，不能共用

}

       Chinese.country="中国";//使用 static后只需要写一次like this
       Chinese c=new  Chinese();
       c.age=11;
        c.name="ddd";
//        c.country="中国";
        Chinese c1=new  Chinese();
        c1.age=11;
        c1.name="ddd";
//        c1.country="中国";
        Chinese c2=new  Chinese();
        c2.age=11;
        c2.name="ddd";
//        c2.country="中国";

类方法也是一样

public static void test(){
    System.out.println("这是一个静态的方法");
}

Chinese.test();

静态方法工具的编写和使用

public class Utils {
    //判断字符串为不为空字符串
    public static boolean isEmpty(String s){
        boolean flag=false;
        if (s!=null&&!s.equals(""));{
            flag=true;
        }
        return flag;

    }

}
测试输出

        String s="11";
//        if (s!=null&&!s.equals(""));{
//        }以后会用到很多这种判断方法就需要封装一个类似工具的静态方法直接调用
        System.out.println(Utils.isEmpty(s));
输出结果 true

static使用范围修饰属性方法代码块内部类被修饰后有以下特点（方法内部不能使用this和super）

1）随着类的加载而加载类加载后，静态的方法或者属性就能使用了（类名.）

2）优先于对象存在不用new就能用

3）修饰的成员被所有对象共享

4）访问权限允许时，可不创建对象，直接被类调用

public class Chinese {
    public Chinese(){
        Chinese.count+=1;
    }
    static String country;//类变量不用实例化，直接类名.属性名就可用使用，是类的一部分，被所有类的实例化对象所共享
    String name;
    public static int count;//计数
    int age;//实例变量实例化之后才能使用，属于实例化的一部分 不能共用
    public static void test(){
        System.out.println("这是一个静态的方法");
    }
public static void showCount(){
        System.out.println("总共new了"+Chinese.count+"个对象");
}

}

Chinese c9=new  Chinese();
Chinese c8=new  Chinese();
Chinese c7=new  Chinese();
Chinese c6=new  Chinese();
Chinese c5=new  Chinese();
System.out.println(Chinese.count);
Chinese.showCount();

六.单例（Singleton）设计模式

public class Singleton {
    public  Singleton(){
        //1000行代码占用很多资源，耗时10S
//        每一次都要new 10s
//        那么这种情况就适合使用Singleton模式只new一次对象以后使用这个对象就不用 了
        
    }
}

Singleton饿汉（在类加载好直接new一个后面直接使用）

public class Singleton {
//    public  Singleton(){
//        //1000行代码占用很多资源，耗时10S
        每一次都要new 10s
        那么这种情况就适合使用Singleton模式只new一次对象以后使用这个对象就不用 了
//
//    }
//    私有的构造 不能直接使用new调用来创建对象
    
    private  Singleton(){
        
    }
//    私有的Singleton类型的变量
    private static Singleton singleton=new Singleton();
    public static Singleton getInstance(){
        return singleton;
    }
}

//       Singleton s=new   Singleton();
        Singleton s1= Singleton.getInstance();
        Singleton s2= Singleton.getInstance();
        Singleton s3= Singleton.getInstance();
        Singleton s4= Singleton.getInstance();

Singleton懒汉（最开始是null，直到有第一个人调用才new一个对象，之后所有调用我的都用这个对象）

public class Singleton1 {
//    私有化构造 让外边不能直接new对象
    private Singleton1(){
        
    }
    private static Singleton1 s1=null;
    public static Singleton1 getInstance(){
        if (s1==null){
            s1=new Singleton1();
        }
        return s1;
    }
    
}
都取的是第一次new的值

//        Singleton1 s=new Singleton1();
        Singleton1 s1= Singleton1.getInstance();
        Singleton1 s2= Singleton1.getInstance();
        Singleton1 s3= Singleton1.getInstance();
        Singleton1 s4= Singleton1.getInstance();
七.理解main方法的语法（配合在cmd中运行进行理解，里面使用的时候数组的数据是用空格隔开的）

public class TestMain {
    public static void main(String[] args) {
        for (int i=0;i<args.length;i++){
            System.out.println(args[i]);
            
        }
    }
}
今天的快乐到此为止，明天希望依旧快乐！！！